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 mutex 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 #define LI_FLAG_ONLIST     4
  57
  58 /* flags in ls_flags*/
  59 #define LS_FLAG_DELETED   1
  60 #define LS_FLAG_AUTOFREE  2
  61
  62
  63 #define LOCKINFO_MAGIC 0x53595324
  64
  65 struct lock_info {
  66         uint32_t li_magic;
  67         uint8_t li_cmd;
  68         int8_t  li_grmode;
  69         int8_t  li_rqmode;
  70         struct dlm_lksb li_lksb;
  71         wait_queue_head_t li_waitq;
  72         unsigned long li_flags;
  73         void __user *li_castparam;
  74         void __user *li_castaddr;
  75         void __user *li_bastparam;
  76         void __user *li_bastaddr;
  77         void __user *li_pend_bastparam;
  78         void __user *li_pend_bastaddr;
  79         struct list_head li_ownerqueue;
  80         struct file_info *li_file;
  81         struct dlm_lksb __user *li_user_lksb;
  82         struct semaphore li_firstlock;
  83 };
  84
  85 /* A queued AST no less */
  86 struct ast_info {
  87         struct dlm_lock_result result;
  88         struct list_head list;
  89         uint32_t lvb_updated;
  90         uint32_t progress;      /* How much has been read */
  91 };
  92
  93 /* One of these per userland lockspace */
  94 struct user_ls {
  95         void    *ls_lockspace;
  96         atomic_t ls_refcnt;
  97         long     ls_flags;
  98
  99         /* Passed into misc_register() */
 100         struct miscdevice ls_miscinfo;
 101         struct list_head  ls_list;
 102 };
 103
 104 /* misc_device info for the control device */
 105 static struct miscdevice ctl_device;
 106
 107 /*
 108  * Stuff we hang off the file struct.
 109  * The first two are to cope with unlocking all the
 110  * locks help by a process when it dies.
 111  */
 112 struct file_info {
 113         struct list_head    fi_li_list;  /* List of active lock_infos */
 114         spinlock_t          fi_li_lock;
 115         struct list_head    fi_ast_list; /* Queue of ASTs to be delivered */
 116         spinlock_t          fi_ast_lock;
 117         wait_queue_head_t   fi_wait;
 118         struct user_ls     *fi_ls;
 119         atomic_t            fi_refcnt;   /* Number of users */
 120         unsigned long       fi_flags;    /* Bit 1 means the device is open */
 121 };
 122
 123
 124 /* get and put ops for file_info.
 125    Actually I don't really like "get" and "put", but everyone
 126    else seems to use them and I can't think of anything
 127    nicer at the moment */
 128 static void get_file_info(struct file_info *f)
 129 {
 130         atomic_inc(&f->fi_refcnt);
 131 }
 132
 133 static void put_file_info(struct file_info *f)
 134 {
 135         if (atomic_dec_and_test(&f->fi_refcnt))
 136                 kfree(f);
 137 }
 138
 139 static void release_lockinfo(struct lock_info *li)
 140 {
 141         put_file_info(li->li_file);
 142
 143         write_lock(&lockinfo_lock);
 144         idr_remove(&lockinfo_idr, li->li_lksb.sb_lkid);
 145         write_unlock(&lockinfo_lock);
 146
 147         if (li->li_lksb.sb_lvbptr)
 148                 kfree(li->li_lksb.sb_lvbptr);
 149         kfree(li);
 150
 151         module_put(THIS_MODULE);
 152 }
 153
 154 static struct lock_info *get_lockinfo(uint32_t lockid)
 155 {
 156         struct lock_info *li;
 157
 158         read_lock(&lockinfo_lock);
 159         li = idr_find(&lockinfo_idr, lockid);
 160         read_unlock(&lockinfo_lock);
 161
 162         return li;
 163 }
 164
 165 static int add_lockinfo(struct lock_info *li)
 166 {
 167         int n;
 168         int r;
 169         int ret = -EINVAL;
 170
 171         write_lock(&lockinfo_lock);
 172
 173         if (idr_find(&lockinfo_idr, li->li_lksb.sb_lkid))
 174                 goto out_up;
 175
 176         ret = -ENOMEM;
 177         r = idr_pre_get(&lockinfo_idr, GFP_KERNEL);
 178         if (!r)
 179                 goto out_up;
 180
 181         r = idr_get_new_above(&lockinfo_idr, li, li->li_lksb.sb_lkid, &n);
 182         if (r)
 183                 goto out_up;
 184
 185         if (n != li->li_lksb.sb_lkid) {
 186                 idr_remove(&lockinfo_idr, n);
 187                 goto out_up;
 188         }
 189
 190         ret = 0;
 191
 192  out_up:
 193         write_unlock(&lockinfo_lock);
 194
 195         return ret;
 196 }
 197
 198
 199 static struct user_ls *__find_lockspace(int minor)
 200 {
 201         struct user_ls *lsinfo;
 202
 203         list_for_each_entry(lsinfo, &user_ls_list, ls_list) {
 204                 if (lsinfo->ls_miscinfo.minor == minor)
 205                         return lsinfo;
 206         }
 207         return NULL;
 208 }
 209
 210 /* Find a lockspace struct given the device minor number */
 211 static struct user_ls *find_lockspace(int minor)
 212 {
 213         struct user_ls *lsinfo;
 214
 215         mutex_lock(&user_ls_lock);
 216         lsinfo = __find_lockspace(minor);
 217         mutex_unlock(&user_ls_lock);
 218
 219         return lsinfo;
 220 }
 221
 222 static void add_lockspace_to_list(struct user_ls *lsinfo)
 223 {
 224         mutex_lock(&user_ls_lock);
 225         list_add(&lsinfo->ls_list, &user_ls_list);
 226         mutex_unlock(&user_ls_lock);
 227 }
 228
 229 /* Register a lockspace with the DLM and create a misc
 230    device for userland to access it */
 231 static int register_lockspace(char *name, struct user_ls **ls, int flags)
 232 {
 233         struct user_ls *newls;
 234         int status;
 235         int namelen;
 236
 237         namelen = strlen(name)+strlen(name_prefix)+2;
 238
 239         newls = kzalloc(sizeof(struct user_ls), GFP_KERNEL);
 240         if (!newls)
 241                 return -ENOMEM;
 242
 243         newls->ls_miscinfo.name = kzalloc(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 mutex 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 = kzalloc(sizeof(struct ast_info), GFP_KERNEL);
 309         if (!ast)
 310                 return;
 311
 312         ast->result.user_astparam = astparam;
 313         ast->result.user_astaddr  = astaddr;
 314         ast->result.user_lksb     = li->li_user_lksb;
 315         memcpy(&ast->result.lksb, &li->li_lksb, sizeof(struct dlm_lksb));
 316         ast->lvb_updated = lvb_updated;
 317
 318         spin_lock(&li->li_file->fi_ast_lock);
 319         list_add_tail(&ast->list, &li->li_file->fi_ast_list);
 320         spin_unlock(&li->li_file->fi_ast_lock);
 321         wake_up_interruptible(&li->li_file->fi_wait);
 322 }
 323
 324 static void bast_routine(void *param, int mode)
 325 {
 326         struct lock_info *li = param;
 327
 328         if (li && li->li_bastaddr)
 329                 add_to_astqueue(li, li->li_bastaddr, li->li_bastparam, 0);
 330 }
 331
 332 /*
 333  * This is the kernel's AST routine.
 334  * All lock, unlock & query operations complete here.
 335  * The only syncronous ops are those done during device close.
 336  */
 337 static void ast_routine(void *param)
 338 {
 339         struct lock_info *li = param;
 340
 341         /* Param may be NULL if a persistent lock is unlocked by someone else */
 342         if (!li)
 343                 return;
 344
 345         /* If this is a succesful conversion then activate the blocking ast
 346          * args from the conversion request */
 347         if (!test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags) &&
 348             li->li_lksb.sb_status == 0) {
 349
 350                 li->li_bastparam = li->li_pend_bastparam;
 351                 li->li_bastaddr = li->li_pend_bastaddr;
 352                 li->li_pend_bastaddr = NULL;
 353         }
 354
 355         /* If it's an async request then post data to the user's AST queue. */
 356         if (li->li_castaddr) {
 357                 int lvb_updated = 0;
 358
 359                 /* See if the lvb has been updated */
 360                 if (dlm_lvb_operations[li->li_grmode+1][li->li_rqmode+1] == 1)
 361                         lvb_updated = 1;
 362
 363                 if (li->li_lksb.sb_status == 0)
 364                         li->li_grmode = li->li_rqmode;
 365
 366                 /* Only queue AST if the device is still open */
 367                 if (test_bit(1, &li->li_file->fi_flags))
 368                         add_to_astqueue(li, li->li_castaddr, li->li_castparam,
 369                                         lvb_updated);
 370
 371                 /* If it's a new lock operation that failed, then
 372                  * remove it from the owner queue and free the
 373                  * lock_info.
 374                  */
 375                 if (test_and_clear_bit(LI_FLAG_FIRSTLOCK, &li->li_flags) &&
 376                     li->li_lksb.sb_status != 0) {
 377
 378                         /* Wait till dlm_lock() has finished */
 379                         down(&li->li_firstlock);
 380                         up(&li->li_firstlock);
 381
 382                         spin_lock(&li->li_file->fi_li_lock);
 383                         list_del(&li->li_ownerqueue);
 384                         clear_bit(LI_FLAG_ONLIST, &li->li_flags);
 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 = kzalloc(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         mutex_lock(&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         mutex_unlock(&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         mutex_lock(&user_ls_lock);
 624         lsinfo = __find_lockspace(kparams->minor);
 625         if (!lsinfo) {
 626                 mutex_unlock(&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         mutex_unlock(&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 = kzalloc(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 && (kparams->flags & DLM_LKF_PERSISTENT)) {
 804                         li = allocate_lockinfo(fi, cmd, kparams);
 805                         if (!li)
 806                                 return -ENOMEM;
 807
 808                         li->li_lksb.sb_lkid = kparams->lkid;
 809                         li->li_castaddr  = kparams->castaddr;
 810                         li->li_castparam = kparams->castparam;
 811
 812                         /* OK, this isn;t exactly a FIRSTLOCK but it is the
 813                            first time we've used this lockinfo, and if things
 814                            fail we want rid of it */
 815                         init_MUTEX_LOCKED(&li->li_firstlock);
 816                         set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
 817                         add_lockinfo(li);
 818
 819                         /* TODO: do a query to get the current state ?? */
 820                 }
 821                 if (!li)
 822                         return -EINVAL;
 823
 824                 if (li->li_magic != LOCKINFO_MAGIC)
 825                         return -EINVAL;
 826
 827                 /* For conversions don't overwrite the current blocking AST
 828                    info so that:
 829                    a) if a blocking AST fires before the conversion is queued
 830                       it runs the current handler
 831                    b) if the conversion is cancelled, the original blocking AST
 832                       declaration is active
 833                    The pend_ info is made active when the conversion
 834                    completes.
 835                 */
 836                 li->li_pend_bastaddr  = kparams->bastaddr;
 837                 li->li_pend_bastparam = kparams->bastparam;
 838         } else {
 839                 li = allocate_lockinfo(fi, cmd, kparams);
 840                 if (!li)
 841                         return -ENOMEM;
 842
 843                 /* semaphore to allow us to complete our work before
 844                    the AST routine runs. In fact we only need (and use) this
 845                    when the initial lock fails */
 846                 init_MUTEX_LOCKED(&li->li_firstlock);
 847                 set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
 848         }
 849
 850         li->li_user_lksb = kparams->lksb;
 851         li->li_castaddr  = kparams->castaddr;
 852         li->li_castparam = kparams->castparam;
 853         li->li_lksb.sb_lkid = kparams->lkid;
 854         li->li_rqmode    = kparams->mode;
 855         if (kparams->flags & DLM_LKF_PERSISTENT)
 856                 set_bit(LI_FLAG_PERSISTENT, &li->li_flags);
 857
 858         /* Copy in the value block */
 859         if (kparams->flags & DLM_LKF_VALBLK) {
 860                 if (!li->li_lksb.sb_lvbptr) {
 861                         li->li_lksb.sb_lvbptr = kmalloc(DLM_USER_LVB_LEN,
 862                                                         GFP_KERNEL);
 863                         if (!li->li_lksb.sb_lvbptr) {
 864                                 status = -ENOMEM;
 865                                 goto out_err;
 866                         }
 867                 }
 868
 869                 memcpy(li->li_lksb.sb_lvbptr, kparams->lvb, DLM_USER_LVB_LEN);
 870         }
 871
 872         /* Lock it ... */
 873         status = dlm_lock(fi->fi_ls->ls_lockspace,
 874                           kparams->mode, &li->li_lksb,
 875                           kparams->flags,
 876                           kparams->name, kparams->namelen,
 877                           kparams->parent,
 878                           ast_routine,
 879                           li,
 880                           (li->li_pend_bastaddr || li->li_bastaddr) ?
 881                            bast_routine : NULL,
 882                           kparams->range.ra_end ? &kparams->range : NULL);
 883         if (status)
 884                 goto out_err;
 885
 886         /* If it succeeded (this far) with a new lock then keep track of
 887            it on the file's lockinfo list */
 888         if (!status && test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags)) {
 889
 890                 spin_lock(&fi->fi_li_lock);
 891                 list_add(&li->li_ownerqueue, &fi->fi_li_list);
 892                 set_bit(LI_FLAG_ONLIST, &li->li_flags);
 893                 spin_unlock(&fi->fi_li_lock);
 894                 if (add_lockinfo(li))
 895                         printk(KERN_WARNING "Add lockinfo failed\n");
 896
 897                 up(&li->li_firstlock);
 898         }
 899
 900         /* Return the lockid as the user needs it /now/ */
 901         return li->li_lksb.sb_lkid;
 902
 903  out_err:
 904         if (test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags))
 905                 release_lockinfo(li);
 906         return status;
 907
 908 }
 909
 910 static int do_user_unlock(struct file_info *fi, uint8_t cmd,
 911                           struct dlm_lock_params *kparams)
 912 {
 913         struct lock_info *li;
 914         int status;
 915         int convert_cancel = 0;
 916
 917         li = get_lockinfo(kparams->lkid);
 918         if (!li) {
 919                 li = allocate_lockinfo(fi, cmd, kparams);
 920                 if (!li)
 921                         return -ENOMEM;
 922                 spin_lock(&fi->fi_li_lock);
 923                 list_add(&li->li_ownerqueue, &fi->fi_li_list);
 924                 set_bit(LI_FLAG_ONLIST, &li->li_flags);
 925                 spin_unlock(&fi->fi_li_lock);
 926         }
 927
 928         if (li->li_magic != LOCKINFO_MAGIC)
 929                 return -EINVAL;
 930
 931         li->li_user_lksb = kparams->lksb;
 932         li->li_castparam = kparams->castparam;
 933         li->li_cmd       = cmd;
 934
 935         /* Cancelling a conversion doesn't remove the lock...*/
 936         if (kparams->flags & DLM_LKF_CANCEL && li->li_grmode != -1)
 937                 convert_cancel = 1;
 938
 939         /* Wait until dlm_lock() has completed */
 940         if (!test_bit(LI_FLAG_ONLIST, &li->li_flags)) {
 941                 down(&li->li_firstlock);
 942                 up(&li->li_firstlock);
 943         }
 944
 945         /* dlm_unlock() passes a 0 for castaddr which means don't overwrite
 946            the existing li_castaddr as that's the completion routine for
 947            unlocks. dlm_unlock_wait() specifies a new AST routine to be
 948            executed when the unlock completes. */
 949         if (kparams->castaddr)
 950                 li->li_castaddr = kparams->castaddr;
 951
 952         /* Use existing lksb & astparams */
 953         status = dlm_unlock(fi->fi_ls->ls_lockspace,
 954                              kparams->lkid,
 955                              kparams->flags, &li->li_lksb, li);
 956
 957         if (!status && !convert_cancel) {
 958                 spin_lock(&fi->fi_li_lock);
 959                 list_del(&li->li_ownerqueue);
 960                 clear_bit(LI_FLAG_ONLIST, &li->li_flags);
 961                 spin_unlock(&fi->fi_li_lock);
 962         }
 963
 964         return status;
 965 }
 966
 967 /* Write call, submit a locking request */
 968 static ssize_t dlm_write(struct file *file, const char __user *buffer,
 969                          size_t count, loff_t *ppos)
 970 {
 971         struct file_info *fi = file->private_data;
 972         struct dlm_write_request *kparams;
 973         sigset_t tmpsig;
 974         sigset_t allsigs;
 975         int status;
 976
 977         /* -1 because lock name is optional */
 978         if (count < sizeof(struct dlm_write_request)-1)
 979                 return -EINVAL;
 980
 981         /* Has the lockspace been deleted */
 982         if (fi && test_bit(LS_FLAG_DELETED, &fi->fi_ls->ls_flags))
 983                 return -ENOENT;
 984
 985         kparams = kmalloc(count, GFP_KERNEL);
 986         if (!kparams)
 987                 return -ENOMEM;
 988
 989         status = -EFAULT;
 990         /* Get the command info */
 991         if (copy_from_user(kparams, buffer, count))
 992                 goto out_free;
 993
 994         status = -EBADE;
 995         if (check_version(kparams))
 996                 goto out_free;
 997
 998         /* Block signals while we are doing this */
 999         sigfillset(&allsigs);
1000         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
1001
1002         status = -EINVAL;
1003         switch (kparams->cmd)
1004         {
1005         case DLM_USER_LOCK:
1006                 if (!fi) goto out_sig;
1007                 status = do_user_lock(fi, kparams->cmd, &kparams->i.lock);
1008                 break;
1009
1010         case DLM_USER_UNLOCK:
1011                 if (!fi) goto out_sig;
1012                 status = do_user_unlock(fi, kparams->cmd, &kparams->i.lock);
1013                 break;
1014
1015         case DLM_USER_CREATE_LOCKSPACE:
1016                 if (fi) goto out_sig;
1017                 status = do_user_create_lockspace(fi, kparams->cmd,
1018                                                   &kparams->i.lspace);
1019                 break;
1020
1021         case DLM_USER_REMOVE_LOCKSPACE:
1022                 if (fi) goto out_sig;
1023                 status = do_user_remove_lockspace(fi, kparams->cmd,
1024                                                   &kparams->i.lspace);
1025                 break;
1026         default:
1027                 printk("Unknown command passed to DLM device : %d\n",
1028                         kparams->cmd);
1029                 break;
1030         }
1031
1032  out_sig:
1033         /* Restore signals */
1034         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
1035         recalc_sigpending();
1036
1037  out_free:
1038         kfree(kparams);
1039         if (status == 0)
1040                 return count;
1041         else
1042                 return status;
1043 }
1044
1045 static struct file_operations _dlm_fops = {
1046       .open    = dlm_open,
1047       .release = dlm_close,
1048       .read    = dlm_read,
1049       .write   = dlm_write,
1050       .poll    = dlm_poll,
1051       .owner   = THIS_MODULE,
1052 };
1053
1054 static struct file_operations _dlm_ctl_fops = {
1055       .open    = dlm_ctl_open,
1056       .release = dlm_ctl_close,
1057       .write   = dlm_write,
1058       .owner   = THIS_MODULE,
1059 };
1060
1061 /*
1062  * Create control device
1063  */
1064 static int __init dlm_device_init(void)
1065 {
1066         int r;
1067
1068         INIT_LIST_HEAD(&user_ls_list);
1069         mutex_init(&user_ls_lock);
1070         rwlock_init(&lockinfo_lock);
1071
1072         ctl_device.name = "dlm-control";
1073         ctl_device.fops = &_dlm_ctl_fops;
1074         ctl_device.minor = MISC_DYNAMIC_MINOR;
1075
1076         r = misc_register(&ctl_device);
1077         if (r) {
1078                 printk(KERN_ERR "dlm: misc_register failed for control dev\n");
1079                 return r;
1080         }
1081
1082         return 0;
1083 }
1084
1085 static void __exit dlm_device_exit(void)
1086 {
1087         misc_deregister(&ctl_device);
1088 }
1089
1090 MODULE_DESCRIPTION("Distributed Lock Manager device interface");
1091 MODULE_AUTHOR("Red Hat, Inc.");
1092 MODULE_LICENSE("GPL");
1093
1094 module_init(dlm_device_init);
1095 module_exit(dlm_device_exit);