[DLM] The core of the DLM for GFS2/CLVM
[linux-3.10.git] / fs / dlm / device.c
1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5 **  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
6 **
7 **  This copyrighted material is made available to anyone wishing to use,
8 **  modify, copy, or redistribute it subject to the terms and conditions
9 **  of the GNU General Public License v.2.
10 **
11 *******************************************************************************
12 ******************************************************************************/
13
14 /*
15  * device.c
16  *
17  * This is the userland interface to the DLM.
18  *
19  * The locking is done via a misc char device (find the
20  * registered minor number in /proc/misc).
21  *
22  * User code should not use this interface directly but
23  * call the library routines in libdlm.a instead.
24  *
25  */
26
27 #include <linux/miscdevice.h>
28 #include <linux/init.h>
29 #include <linux/wait.h>
30 #include <linux/module.h>
31 #include <linux/file.h>
32 #include <linux/fs.h>
33 #include <linux/poll.h>
34 #include <linux/signal.h>
35 #include <linux/spinlock.h>
36 #include <linux/idr.h>
37
38 #include <linux/dlm.h>
39 #include <linux/dlm_device.h>
40
41 #include "lvb_table.h"
42
43 static struct file_operations _dlm_fops;
44 static const char *name_prefix="dlm";
45 static struct list_head user_ls_list;
46 static struct semaphore user_ls_lock;
47
48 /* Lock infos are stored in here indexed by lock ID */
49 static DEFINE_IDR(lockinfo_idr);
50 static rwlock_t lockinfo_lock;
51
52 /* Flags in li_flags */
53 #define LI_FLAG_COMPLETE   1
54 #define LI_FLAG_FIRSTLOCK  2
55 #define LI_FLAG_PERSISTENT 3
56
57 /* flags in ls_flags*/
58 #define LS_FLAG_DELETED   1
59 #define LS_FLAG_AUTOFREE  2
60
61
62 #define LOCKINFO_MAGIC 0x53595324
63
64 struct lock_info {
65         uint32_t li_magic;
66         uint8_t li_cmd;
67         int8_t  li_grmode;
68         int8_t  li_rqmode;
69         struct dlm_lksb li_lksb;
70         wait_queue_head_t li_waitq;
71         unsigned long li_flags;
72         void __user *li_castparam;
73         void __user *li_castaddr;
74         void __user *li_bastparam;
75         void __user *li_bastaddr;
76         void __user *li_pend_bastparam;
77         void __user *li_pend_bastaddr;
78         struct list_head li_ownerqueue;
79         struct file_info *li_file;
80         struct dlm_lksb __user *li_user_lksb;
81         struct semaphore li_firstlock;
82 };
83
84 /* A queued AST no less */
85 struct ast_info {
86         struct dlm_lock_result result;
87         struct list_head list;
88         uint32_t lvb_updated;
89         uint32_t progress;      /* How much has been read */
90 };
91
92 /* One of these per userland lockspace */
93 struct user_ls {
94         void    *ls_lockspace;
95         atomic_t ls_refcnt;
96         long     ls_flags;
97
98         /* Passed into misc_register() */
99         struct miscdevice ls_miscinfo;
100         struct list_head  ls_list;
101 };
102
103 /* misc_device info for the control device */
104 static struct miscdevice ctl_device;
105
106 /*
107  * Stuff we hang off the file struct.
108  * The first two are to cope with unlocking all the
109  * locks help by a process when it dies.
110  */
111 struct file_info {
112         struct list_head    fi_li_list;  /* List of active lock_infos */
113         spinlock_t          fi_li_lock;
114         struct list_head    fi_ast_list; /* Queue of ASTs to be delivered */
115         spinlock_t          fi_ast_lock;
116         wait_queue_head_t   fi_wait;
117         struct user_ls     *fi_ls;
118         atomic_t            fi_refcnt;   /* Number of users */
119         unsigned long       fi_flags;    /* Bit 1 means the device is open */
120 };
121
122
123 /* get and put ops for file_info.
124    Actually I don't really like "get" and "put", but everyone
125    else seems to use them and I can't think of anything
126    nicer at the moment */
127 static void get_file_info(struct file_info *f)
128 {
129         atomic_inc(&f->fi_refcnt);
130 }
131
132 static void put_file_info(struct file_info *f)
133 {
134         if (atomic_dec_and_test(&f->fi_refcnt))
135                 kfree(f);
136 }
137
138 static void release_lockinfo(struct lock_info *li)
139 {
140         put_file_info(li->li_file);
141
142         write_lock(&lockinfo_lock);
143         idr_remove(&lockinfo_idr, li->li_lksb.sb_lkid);
144         write_unlock(&lockinfo_lock);
145
146         if (li->li_lksb.sb_lvbptr)
147                 kfree(li->li_lksb.sb_lvbptr);
148         kfree(li);
149
150         module_put(THIS_MODULE);
151 }
152
153 static struct lock_info *get_lockinfo(uint32_t lockid)
154 {
155         struct lock_info *li;
156
157         read_lock(&lockinfo_lock);
158         li = idr_find(&lockinfo_idr, lockid);
159         read_unlock(&lockinfo_lock);
160
161         return li;
162 }
163
164 static int add_lockinfo(struct lock_info *li)
165 {
166         int n;
167         int r;
168         int ret = -EINVAL;
169
170         write_lock(&lockinfo_lock);
171
172         if (idr_find(&lockinfo_idr, li->li_lksb.sb_lkid))
173                 goto out_up;
174
175         ret = -ENOMEM;
176         r = idr_pre_get(&lockinfo_idr, GFP_KERNEL);
177         if (!r)
178                 goto out_up;
179
180         r = idr_get_new_above(&lockinfo_idr, li, li->li_lksb.sb_lkid, &n);
181         if (r)
182                 goto out_up;
183
184         if (n != li->li_lksb.sb_lkid) {
185                 idr_remove(&lockinfo_idr, n);
186                 goto out_up;
187         }
188
189         ret = 0;
190
191  out_up:
192         write_unlock(&lockinfo_lock);
193
194         return ret;
195 }
196
197
198 static struct user_ls *__find_lockspace(int minor)
199 {
200         struct user_ls *lsinfo;
201
202         list_for_each_entry(lsinfo, &user_ls_list, ls_list) {
203                 if (lsinfo->ls_miscinfo.minor == minor)
204                         return lsinfo;
205         }
206         return NULL;
207 }
208
209 /* Find a lockspace struct given the device minor number */
210 static struct user_ls *find_lockspace(int minor)
211 {
212         struct user_ls *lsinfo;
213
214         down(&user_ls_lock);
215         lsinfo = __find_lockspace(minor);
216         up(&user_ls_lock);
217
218         return lsinfo;
219 }
220
221 static void add_lockspace_to_list(struct user_ls *lsinfo)
222 {
223         down(&user_ls_lock);
224         list_add(&lsinfo->ls_list, &user_ls_list);
225         up(&user_ls_lock);
226 }
227
228 /* Register a lockspace with the DLM and create a misc
229    device for userland to access it */
230 static int register_lockspace(char *name, struct user_ls **ls, int flags)
231 {
232         struct user_ls *newls;
233         int status;
234         int namelen;
235
236         namelen = strlen(name)+strlen(name_prefix)+2;
237
238         newls = kmalloc(sizeof(struct user_ls), GFP_KERNEL);
239         if (!newls)
240                 return -ENOMEM;
241         memset(newls, 0, sizeof(struct user_ls));
242
243         newls->ls_miscinfo.name = kmalloc(namelen, GFP_KERNEL);
244         if (!newls->ls_miscinfo.name) {
245                 kfree(newls);
246                 return -ENOMEM;
247         }
248
249         status = dlm_new_lockspace(name, strlen(name), &newls->ls_lockspace, 0,
250                                    DLM_USER_LVB_LEN);
251         if (status != 0) {
252                 kfree(newls->ls_miscinfo.name);
253                 kfree(newls);
254                 return status;
255         }
256
257         snprintf((char*)newls->ls_miscinfo.name, namelen, "%s_%s",
258                  name_prefix, name);
259
260         newls->ls_miscinfo.fops = &_dlm_fops;
261         newls->ls_miscinfo.minor = MISC_DYNAMIC_MINOR;
262
263         status = misc_register(&newls->ls_miscinfo);
264         if (status) {
265                 printk(KERN_ERR "dlm: misc register failed for %s\n", name);
266                 dlm_release_lockspace(newls->ls_lockspace, 0);
267                 kfree(newls->ls_miscinfo.name);
268                 kfree(newls);
269                 return status;
270         }
271
272         if (flags & DLM_USER_LSFLG_AUTOFREE)
273                 set_bit(LS_FLAG_AUTOFREE, &newls->ls_flags);
274
275         add_lockspace_to_list(newls);
276         *ls = newls;
277         return 0;
278 }
279
280 /* Called with the user_ls_lock semaphore held */
281 static int unregister_lockspace(struct user_ls *lsinfo, int force)
282 {
283         int status;
284
285         status = dlm_release_lockspace(lsinfo->ls_lockspace, force);
286         if (status)
287                 return status;
288
289         status = misc_deregister(&lsinfo->ls_miscinfo);
290         if (status)
291                 return status;
292
293         list_del(&lsinfo->ls_list);
294         set_bit(LS_FLAG_DELETED, &lsinfo->ls_flags);
295         lsinfo->ls_lockspace = NULL;
296         if (atomic_read(&lsinfo->ls_refcnt) == 0) {
297                 kfree(lsinfo->ls_miscinfo.name);
298                 kfree(lsinfo);
299         }
300
301         return 0;
302 }
303
304 /* Add it to userland's AST queue */
305 static void add_to_astqueue(struct lock_info *li, void *astaddr, void *astparam,
306                             int lvb_updated)
307 {
308         struct ast_info *ast = kmalloc(sizeof(struct ast_info), GFP_KERNEL);
309         if (!ast)
310                 return;
311
312         memset(ast, 0, sizeof(*ast));
313         ast->result.user_astparam = astparam;
314         ast->result.user_astaddr  = astaddr;
315         ast->result.user_lksb     = li->li_user_lksb;
316         memcpy(&ast->result.lksb, &li->li_lksb, sizeof(struct dlm_lksb));
317         ast->lvb_updated = lvb_updated;
318
319         spin_lock(&li->li_file->fi_ast_lock);
320         list_add_tail(&ast->list, &li->li_file->fi_ast_list);
321         spin_unlock(&li->li_file->fi_ast_lock);
322         wake_up_interruptible(&li->li_file->fi_wait);
323 }
324
325 static void bast_routine(void *param, int mode)
326 {
327         struct lock_info *li = param;
328
329         if (li && li->li_bastaddr)
330                 add_to_astqueue(li, li->li_bastaddr, li->li_bastparam, 0);
331 }
332
333 /*
334  * This is the kernel's AST routine.
335  * All lock, unlock & query operations complete here.
336  * The only syncronous ops are those done during device close.
337  */
338 static void ast_routine(void *param)
339 {
340         struct lock_info *li = param;
341
342         /* Param may be NULL if a persistent lock is unlocked by someone else */
343         if (!li)
344                 return;
345
346         /* If this is a succesful conversion then activate the blocking ast
347          * args from the conversion request */
348         if (!test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags) &&
349             li->li_lksb.sb_status == 0) {
350
351                 li->li_bastparam = li->li_pend_bastparam;
352                 li->li_bastaddr = li->li_pend_bastaddr;
353                 li->li_pend_bastaddr = NULL;
354         }
355
356         /* If it's an async request then post data to the user's AST queue. */
357         if (li->li_castaddr) {
358                 int lvb_updated = 0;
359
360                 /* See if the lvb has been updated */
361                 if (dlm_lvb_operations[li->li_grmode+1][li->li_rqmode+1] == 1)
362                         lvb_updated = 1;
363
364                 if (li->li_lksb.sb_status == 0)
365                         li->li_grmode = li->li_rqmode;
366
367                 /* Only queue AST if the device is still open */
368                 if (test_bit(1, &li->li_file->fi_flags))
369                         add_to_astqueue(li, li->li_castaddr, li->li_castparam,
370                                         lvb_updated);
371
372                 /* If it's a new lock operation that failed, then
373                  * remove it from the owner queue and free the
374                  * lock_info.
375                  */
376                 if (test_and_clear_bit(LI_FLAG_FIRSTLOCK, &li->li_flags) &&
377                     li->li_lksb.sb_status != 0) {
378
379                         /* Wait till dlm_lock() has finished */
380                         down(&li->li_firstlock);
381                         up(&li->li_firstlock);
382
383                         spin_lock(&li->li_file->fi_li_lock);
384                         list_del(&li->li_ownerqueue);
385                         spin_unlock(&li->li_file->fi_li_lock);
386                         release_lockinfo(li);
387                         return;
388                 }
389                 /* Free unlocks & queries */
390                 if (li->li_lksb.sb_status == -DLM_EUNLOCK ||
391                     li->li_cmd == DLM_USER_QUERY) {
392                         release_lockinfo(li);
393                 }
394         } else {
395                 /* Synchronous request, just wake up the caller */
396                 set_bit(LI_FLAG_COMPLETE, &li->li_flags);
397                 wake_up_interruptible(&li->li_waitq);
398         }
399 }
400
401 /*
402  * Wait for the lock op to complete and return the status.
403  */
404 static int wait_for_ast(struct lock_info *li)
405 {
406         /* Wait for the AST routine to complete */
407         set_task_state(current, TASK_INTERRUPTIBLE);
408         while (!test_bit(LI_FLAG_COMPLETE, &li->li_flags))
409                 schedule();
410
411         set_task_state(current, TASK_RUNNING);
412
413         return li->li_lksb.sb_status;
414 }
415
416
417 /* Open on control device */
418 static int dlm_ctl_open(struct inode *inode, struct file *file)
419 {
420         file->private_data = NULL;
421         return 0;
422 }
423
424 /* Close on control device */
425 static int dlm_ctl_close(struct inode *inode, struct file *file)
426 {
427         return 0;
428 }
429
430 /* Open on lockspace device */
431 static int dlm_open(struct inode *inode, struct file *file)
432 {
433         struct file_info *f;
434         struct user_ls *lsinfo;
435
436         lsinfo = find_lockspace(iminor(inode));
437         if (!lsinfo)
438                 return -ENOENT;
439
440         f = kmalloc(sizeof(struct file_info), GFP_KERNEL);
441         if (!f)
442                 return -ENOMEM;
443
444         atomic_inc(&lsinfo->ls_refcnt);
445         INIT_LIST_HEAD(&f->fi_li_list);
446         INIT_LIST_HEAD(&f->fi_ast_list);
447         spin_lock_init(&f->fi_li_lock);
448         spin_lock_init(&f->fi_ast_lock);
449         init_waitqueue_head(&f->fi_wait);
450         f->fi_ls = lsinfo;
451         f->fi_flags = 0;
452         get_file_info(f);
453         set_bit(1, &f->fi_flags);
454
455         file->private_data = f;
456
457         return 0;
458 }
459
460 /* Check the user's version matches ours */
461 static int check_version(struct dlm_write_request *req)
462 {
463         if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
464             (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
465              req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
466
467                 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
468                        "user (%d.%d.%d) kernel (%d.%d.%d)\n",
469                        current->comm,
470                        current->pid,
471                        req->version[0],
472                        req->version[1],
473                        req->version[2],
474                        DLM_DEVICE_VERSION_MAJOR,
475                        DLM_DEVICE_VERSION_MINOR,
476                        DLM_DEVICE_VERSION_PATCH);
477                 return -EINVAL;
478         }
479         return 0;
480 }
481
482 /* Close on lockspace device */
483 static int dlm_close(struct inode *inode, struct file *file)
484 {
485         struct file_info *f = file->private_data;
486         struct lock_info li;
487         struct lock_info *old_li, *safe;
488         sigset_t tmpsig;
489         sigset_t allsigs;
490         struct user_ls *lsinfo;
491         DECLARE_WAITQUEUE(wq, current);
492
493         lsinfo = find_lockspace(iminor(inode));
494         if (!lsinfo)
495                 return -ENOENT;
496
497         /* Mark this closed so that ASTs will not be delivered any more */
498         clear_bit(1, &f->fi_flags);
499
500         /* Block signals while we are doing this */
501         sigfillset(&allsigs);
502         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
503
504         /* We use our own lock_info struct here, so that any
505          * outstanding "real" ASTs will be delivered with the
506          * corresponding "real" params, thus freeing the lock_info
507          * that belongs the lock. This catches the corner case where
508          * a lock is BUSY when we try to unlock it here
509          */
510         memset(&li, 0, sizeof(li));
511         clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
512         init_waitqueue_head(&li.li_waitq);
513         add_wait_queue(&li.li_waitq, &wq);
514
515         /*
516          * Free any outstanding locks, they are on the
517          * list in LIFO order so there should be no problems
518          * about unlocking parents before children.
519          */
520         list_for_each_entry_safe(old_li, safe, &f->fi_li_list, li_ownerqueue) {
521                 int status;
522                 int flags = 0;
523
524                 /* Don't unlock persistent locks, just mark them orphaned */
525                 if (test_bit(LI_FLAG_PERSISTENT, &old_li->li_flags)) {
526                         list_del(&old_li->li_ownerqueue);
527
528                         /* Update master copy */
529                         /* TODO: Check locking core updates the local and
530                            remote ORPHAN flags */
531                         li.li_lksb.sb_lkid = old_li->li_lksb.sb_lkid;
532                         status = dlm_lock(f->fi_ls->ls_lockspace,
533                                           old_li->li_grmode, &li.li_lksb,
534                                           DLM_LKF_CONVERT|DLM_LKF_ORPHAN,
535                                           NULL, 0, 0, ast_routine, NULL,
536                                           NULL, NULL);
537                         if (status != 0)
538                                 printk("dlm: Error orphaning lock %x: %d\n",
539                                        old_li->li_lksb.sb_lkid, status);
540
541                         /* But tidy our references in it */
542                         release_lockinfo(old_li);
543                         continue;
544                 }
545
546                 clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
547
548                 flags = DLM_LKF_FORCEUNLOCK;
549                 if (old_li->li_grmode >= DLM_LOCK_PW)
550                         flags |= DLM_LKF_IVVALBLK;
551
552                 status = dlm_unlock(f->fi_ls->ls_lockspace,
553                                     old_li->li_lksb.sb_lkid, flags,
554                                     &li.li_lksb, &li);
555
556                 /* Must wait for it to complete as the next lock could be its
557                  * parent */
558                 if (status == 0)
559                         wait_for_ast(&li);
560
561                 /* Unlock suceeded, free the lock_info struct. */
562                 if (status == 0)
563                         release_lockinfo(old_li);
564         }
565
566         remove_wait_queue(&li.li_waitq, &wq);
567
568         /*
569          * If this is the last reference to the lockspace
570          * then free the struct. If it's an AUTOFREE lockspace
571          * then free the whole thing.
572          */
573         down(&user_ls_lock);
574         if (atomic_dec_and_test(&lsinfo->ls_refcnt)) {
575
576                 if (lsinfo->ls_lockspace) {
577                         if (test_bit(LS_FLAG_AUTOFREE, &lsinfo->ls_flags)) {
578                                 unregister_lockspace(lsinfo, 1);
579                         }
580                 } else {
581                         kfree(lsinfo->ls_miscinfo.name);
582                         kfree(lsinfo);
583                 }
584         }
585         up(&user_ls_lock);
586         put_file_info(f);
587
588         /* Restore signals */
589         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
590         recalc_sigpending();
591
592         return 0;
593 }
594
595 static int do_user_create_lockspace(struct file_info *fi, uint8_t cmd,
596                                     struct dlm_lspace_params *kparams)
597 {
598         int status;
599         struct user_ls *lsinfo;
600
601         if (!capable(CAP_SYS_ADMIN))
602                 return -EPERM;
603
604         status = register_lockspace(kparams->name, &lsinfo, kparams->flags);
605
606         /* If it succeeded then return the minor number */
607         if (status == 0)
608                 status = lsinfo->ls_miscinfo.minor;
609
610         return status;
611 }
612
613 static int do_user_remove_lockspace(struct file_info *fi, uint8_t cmd,
614                                     struct dlm_lspace_params *kparams)
615 {
616         int status;
617         int force = 1;
618         struct user_ls *lsinfo;
619
620         if (!capable(CAP_SYS_ADMIN))
621                 return -EPERM;
622
623         down(&user_ls_lock);
624         lsinfo = __find_lockspace(kparams->minor);
625         if (!lsinfo) {
626                 up(&user_ls_lock);
627                 return -EINVAL;
628         }
629
630         if (kparams->flags & DLM_USER_LSFLG_FORCEFREE)
631                 force = 2;
632
633         status = unregister_lockspace(lsinfo, force);
634         up(&user_ls_lock);
635
636         return status;
637 }
638
639 /* Read call, might block if no ASTs are waiting.
640  * It will only ever return one message at a time, regardless
641  * of how many are pending.
642  */
643 static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count,
644                         loff_t *ppos)
645 {
646         struct file_info *fi = file->private_data;
647         struct ast_info *ast;
648         int data_size;
649         int offset;
650         DECLARE_WAITQUEUE(wait, current);
651
652         if (count < sizeof(struct dlm_lock_result))
653                 return -EINVAL;
654
655         spin_lock(&fi->fi_ast_lock);
656         if (list_empty(&fi->fi_ast_list)) {
657
658                 /* No waiting ASTs.
659                  * Return EOF if the lockspace been deleted.
660                  */
661                 if (test_bit(LS_FLAG_DELETED, &fi->fi_ls->ls_flags))
662                         return 0;
663
664                 if (file->f_flags & O_NONBLOCK) {
665                         spin_unlock(&fi->fi_ast_lock);
666                         return -EAGAIN;
667                 }
668
669                 add_wait_queue(&fi->fi_wait, &wait);
670
671         repeat:
672                 set_current_state(TASK_INTERRUPTIBLE);
673                 if (list_empty(&fi->fi_ast_list) &&
674                     !signal_pending(current)) {
675
676                         spin_unlock(&fi->fi_ast_lock);
677                         schedule();
678                         spin_lock(&fi->fi_ast_lock);
679                         goto repeat;
680                 }
681
682                 current->state = TASK_RUNNING;
683                 remove_wait_queue(&fi->fi_wait, &wait);
684
685                 if (signal_pending(current)) {
686                         spin_unlock(&fi->fi_ast_lock);
687                         return -ERESTARTSYS;
688                 }
689         }
690
691         ast = list_entry(fi->fi_ast_list.next, struct ast_info, list);
692         list_del(&ast->list);
693         spin_unlock(&fi->fi_ast_lock);
694
695         /* Work out the size of the returned data */
696         data_size = sizeof(struct dlm_lock_result);
697         if (ast->lvb_updated && ast->result.lksb.sb_lvbptr)
698                 data_size += DLM_USER_LVB_LEN;
699
700         offset = sizeof(struct dlm_lock_result);
701
702         /* Room for the extended data ? */
703         if (count >= data_size) {
704
705                 if (ast->lvb_updated && ast->result.lksb.sb_lvbptr) {
706                         if (copy_to_user(buffer+offset,
707                                          ast->result.lksb.sb_lvbptr,
708                                          DLM_USER_LVB_LEN))
709                                 return -EFAULT;
710                         ast->result.lvb_offset = offset;
711                         offset += DLM_USER_LVB_LEN;
712                 }
713         }
714
715         ast->result.length = data_size;
716         /* Copy the header now it has all the offsets in it */
717         if (copy_to_user(buffer, &ast->result, sizeof(struct dlm_lock_result)))
718                 offset = -EFAULT;
719
720         /* If we only returned a header and there's more to come then put it
721            back on the list */
722         if (count < data_size) {
723                 spin_lock(&fi->fi_ast_lock);
724                 list_add(&ast->list, &fi->fi_ast_list);
725                 spin_unlock(&fi->fi_ast_lock);
726         } else
727                 kfree(ast);
728         return offset;
729 }
730
731 static unsigned int dlm_poll(struct file *file, poll_table *wait)
732 {
733         struct file_info *fi = file->private_data;
734
735         poll_wait(file, &fi->fi_wait, wait);
736
737         spin_lock(&fi->fi_ast_lock);
738         if (!list_empty(&fi->fi_ast_list)) {
739                 spin_unlock(&fi->fi_ast_lock);
740                 return POLLIN | POLLRDNORM;
741         }
742
743         spin_unlock(&fi->fi_ast_lock);
744         return 0;
745 }
746
747 static struct lock_info *allocate_lockinfo(struct file_info *fi, uint8_t cmd,
748                                            struct dlm_lock_params *kparams)
749 {
750         struct lock_info *li;
751
752         if (!try_module_get(THIS_MODULE))
753                 return NULL;
754
755         li = kmalloc(sizeof(struct lock_info), GFP_KERNEL);
756         if (li) {
757                 li->li_magic     = LOCKINFO_MAGIC;
758                 li->li_file      = fi;
759                 li->li_cmd       = cmd;
760                 li->li_flags     = 0;
761                 li->li_grmode    = -1;
762                 li->li_rqmode    = -1;
763                 li->li_pend_bastparam = NULL;
764                 li->li_pend_bastaddr  = NULL;
765                 li->li_castaddr   = NULL;
766                 li->li_castparam  = NULL;
767                 li->li_lksb.sb_lvbptr = NULL;
768                 li->li_bastaddr  = kparams->bastaddr;
769                 li->li_bastparam = kparams->bastparam;
770
771                 get_file_info(fi);
772         }
773         return li;
774 }
775
776 static int do_user_lock(struct file_info *fi, uint8_t cmd,
777                         struct dlm_lock_params *kparams)
778 {
779         struct lock_info *li;
780         int status;
781
782         /*
783          * Validate things that we need to have correct.
784          */
785         if (!kparams->castaddr)
786                 return -EINVAL;
787
788         if (!kparams->lksb)
789                 return -EINVAL;
790
791         /* Persistent child locks are not available yet */
792         if ((kparams->flags & DLM_LKF_PERSISTENT) && kparams->parent)
793                 return -EINVAL;
794
795         /* For conversions, there should already be a lockinfo struct,
796            unless we are adopting an orphaned persistent lock */
797         if (kparams->flags & DLM_LKF_CONVERT) {
798
799                 li = get_lockinfo(kparams->lkid);
800
801                 /* If this is a persistent lock we will have to create a
802                    lockinfo again */
803                 if (!li && DLM_LKF_PERSISTENT) {
804                         li = allocate_lockinfo(fi, cmd, kparams);
805
806                         li->li_lksb.sb_lkid = kparams->lkid;
807                         li->li_castaddr  = kparams->castaddr;
808                         li->li_castparam = kparams->castparam;
809
810                         /* OK, this isn;t exactly a FIRSTLOCK but it is the
811                            first time we've used this lockinfo, and if things
812                            fail we want rid of it */
813                         init_MUTEX_LOCKED(&li->li_firstlock);
814                         set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
815                         add_lockinfo(li);
816
817                         /* TODO: do a query to get the current state ?? */
818                 }
819                 if (!li)
820                         return -EINVAL;
821
822                 if (li->li_magic != LOCKINFO_MAGIC)
823                         return -EINVAL;
824
825                 /* For conversions don't overwrite the current blocking AST
826                    info so that:
827                    a) if a blocking AST fires before the conversion is queued
828                       it runs the current handler
829                    b) if the conversion is cancelled, the original blocking AST
830                       declaration is active
831                    The pend_ info is made active when the conversion
832                    completes.
833                 */
834                 li->li_pend_bastaddr  = kparams->bastaddr;
835                 li->li_pend_bastparam = kparams->bastparam;
836         } else {
837                 li = allocate_lockinfo(fi, cmd, kparams);
838                 if (!li)
839                         return -ENOMEM;
840
841                 /* semaphore to allow us to complete our work before
842                    the AST routine runs. In fact we only need (and use) this
843                    when the initial lock fails */
844                 init_MUTEX_LOCKED(&li->li_firstlock);
845                 set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
846         }
847
848         li->li_user_lksb = kparams->lksb;
849         li->li_castaddr  = kparams->castaddr;
850         li->li_castparam = kparams->castparam;
851         li->li_lksb.sb_lkid = kparams->lkid;
852         li->li_rqmode    = kparams->mode;
853         if (kparams->flags & DLM_LKF_PERSISTENT)
854                 set_bit(LI_FLAG_PERSISTENT, &li->li_flags);
855
856         /* Copy in the value block */
857         if (kparams->flags & DLM_LKF_VALBLK) {
858                 if (!li->li_lksb.sb_lvbptr) {
859                         li->li_lksb.sb_lvbptr = kmalloc(DLM_USER_LVB_LEN,
860                                                         GFP_KERNEL);
861                         if (!li->li_lksb.sb_lvbptr) {
862                                 status = -ENOMEM;
863                                 goto out_err;
864                         }
865                 }
866
867                 memcpy(li->li_lksb.sb_lvbptr, kparams->lvb, DLM_USER_LVB_LEN);
868         }
869
870         /* Lock it ... */
871         status = dlm_lock(fi->fi_ls->ls_lockspace,
872                           kparams->mode, &li->li_lksb,
873                           kparams->flags,
874                           kparams->name, kparams->namelen,
875                           kparams->parent,
876                           ast_routine,
877                           li,
878                           (li->li_pend_bastaddr || li->li_bastaddr) ?
879                            bast_routine : NULL,
880                           kparams->range.ra_end ? &kparams->range : NULL);
881         if (status)
882                 goto out_err;
883
884         /* If it succeeded (this far) with a new lock then keep track of
885            it on the file's lockinfo list */
886         if (!status && test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags)) {
887
888                 spin_lock(&fi->fi_li_lock);
889                 list_add(&li->li_ownerqueue, &fi->fi_li_list);
890                 spin_unlock(&fi->fi_li_lock);
891                 if (add_lockinfo(li))
892                         printk(KERN_WARNING "Add lockinfo failed\n");
893
894                 up(&li->li_firstlock);
895         }
896
897         /* Return the lockid as the user needs it /now/ */
898         return li->li_lksb.sb_lkid;
899
900  out_err:
901         if (test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags))
902                 release_lockinfo(li);
903         return status;
904
905 }
906
907 static int do_user_unlock(struct file_info *fi, uint8_t cmd,
908                           struct dlm_lock_params *kparams)
909 {
910         struct lock_info *li;
911         int status;
912         int convert_cancel = 0;
913
914         li = get_lockinfo(kparams->lkid);
915         if (!li) {
916                 li = allocate_lockinfo(fi, cmd, kparams);
917                 spin_lock(&fi->fi_li_lock);
918                 list_add(&li->li_ownerqueue, &fi->fi_li_list);
919                 spin_unlock(&fi->fi_li_lock);
920         }
921         if (!li)
922                 return -ENOMEM;
923
924         if (li->li_magic != LOCKINFO_MAGIC)
925                 return -EINVAL;
926
927         li->li_user_lksb = kparams->lksb;
928         li->li_castparam = kparams->castparam;
929         li->li_cmd       = cmd;
930
931         /* Cancelling a conversion doesn't remove the lock...*/
932         if (kparams->flags & DLM_LKF_CANCEL && li->li_grmode != -1)
933                 convert_cancel = 1;
934
935         /* dlm_unlock() passes a 0 for castaddr which means don't overwrite
936            the existing li_castaddr as that's the completion routine for
937            unlocks. dlm_unlock_wait() specifies a new AST routine to be
938            executed when the unlock completes. */
939         if (kparams->castaddr)
940                 li->li_castaddr = kparams->castaddr;
941
942         /* Use existing lksb & astparams */
943         status = dlm_unlock(fi->fi_ls->ls_lockspace,
944                              kparams->lkid,
945                              kparams->flags, &li->li_lksb, li);
946
947         if (!status && !convert_cancel) {
948                 spin_lock(&fi->fi_li_lock);
949                 list_del(&li->li_ownerqueue);
950                 spin_unlock(&fi->fi_li_lock);
951         }
952
953         return status;
954 }
955
956 /* Write call, submit a locking request */
957 static ssize_t dlm_write(struct file *file, const char __user *buffer,
958                          size_t count, loff_t *ppos)
959 {
960         struct file_info *fi = file->private_data;
961         struct dlm_write_request *kparams;
962         sigset_t tmpsig;
963         sigset_t allsigs;
964         int status;
965
966         /* -1 because lock name is optional */
967         if (count < sizeof(struct dlm_write_request)-1)
968                 return -EINVAL;
969
970         /* Has the lockspace been deleted */
971         if (fi && test_bit(LS_FLAG_DELETED, &fi->fi_ls->ls_flags))
972                 return -ENOENT;
973
974         kparams = kmalloc(count, GFP_KERNEL);
975         if (!kparams)
976                 return -ENOMEM;
977
978         status = -EFAULT;
979         /* Get the command info */
980         if (copy_from_user(kparams, buffer, count))
981                 goto out_free;
982
983         status = -EBADE;
984         if (check_version(kparams))
985                 goto out_free;
986
987         /* Block signals while we are doing this */
988         sigfillset(&allsigs);
989         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
990
991         status = -EINVAL;
992         switch (kparams->cmd)
993         {
994         case DLM_USER_LOCK:
995                 if (!fi) goto out_sig;
996                 status = do_user_lock(fi, kparams->cmd, &kparams->i.lock);
997                 break;
998
999         case DLM_USER_UNLOCK:
1000                 if (!fi) goto out_sig;
1001                 status = do_user_unlock(fi, kparams->cmd, &kparams->i.lock);
1002                 break;
1003
1004         case DLM_USER_CREATE_LOCKSPACE:
1005                 if (fi) goto out_sig;
1006                 status = do_user_create_lockspace(fi, kparams->cmd,
1007                                                   &kparams->i.lspace);
1008                 break;
1009
1010         case DLM_USER_REMOVE_LOCKSPACE:
1011                 if (fi) goto out_sig;
1012                 status = do_user_remove_lockspace(fi, kparams->cmd,
1013                                                   &kparams->i.lspace);
1014                 break;
1015         default:
1016                 printk("Unknown command passed to DLM device : %d\n",
1017                         kparams->cmd);
1018                 break;
1019         }
1020
1021  out_sig:
1022         /* Restore signals */
1023         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
1024         recalc_sigpending();
1025
1026  out_free:
1027         kfree(kparams);
1028         if (status == 0)
1029                 return count;
1030         else
1031                 return status;
1032 }
1033
1034 static struct file_operations _dlm_fops = {
1035       .open    = dlm_open,
1036       .release = dlm_close,
1037       .read    = dlm_read,
1038       .write   = dlm_write,
1039       .poll    = dlm_poll,
1040       .owner   = THIS_MODULE,
1041 };
1042
1043 static struct file_operations _dlm_ctl_fops = {
1044       .open    = dlm_ctl_open,
1045       .release = dlm_ctl_close,
1046       .write   = dlm_write,
1047       .owner   = THIS_MODULE,
1048 };
1049
1050 /*
1051  * Create control device
1052  */
1053 static int __init dlm_device_init(void)
1054 {
1055         int r;
1056
1057         INIT_LIST_HEAD(&user_ls_list);
1058         init_MUTEX(&user_ls_lock);
1059         rwlock_init(&lockinfo_lock);
1060
1061         ctl_device.name = "dlm-control";
1062         ctl_device.fops = &_dlm_ctl_fops;
1063         ctl_device.minor = MISC_DYNAMIC_MINOR;
1064
1065         r = misc_register(&ctl_device);
1066         if (r) {
1067                 printk(KERN_ERR "dlm: misc_register failed for control dev\n");
1068                 return r;
1069         }
1070
1071         return 0;
1072 }
1073
1074 static void __exit dlm_device_exit(void)
1075 {
1076         misc_deregister(&ctl_device);
1077 }
1078
1079 MODULE_DESCRIPTION("Distributed Lock Manager device interface");
1080 MODULE_AUTHOR("Red Hat, Inc.");
1081 MODULE_LICENSE("GPL");
1082
1083 module_init(dlm_device_init);
1084 module_exit(dlm_device_exit);