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, NULL);
 536                         if (status != 0)
 537                                 printk("dlm: Error orphaning lock %x: %d\n",
 538                                        old_li->li_lksb.sb_lkid, status);
 539
 540                         /* But tidy our references in it */
 541                         release_lockinfo(old_li);
 542                         continue;
 543                 }
 544
 545                 clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
 546
 547                 flags = DLM_LKF_FORCEUNLOCK;
 548                 if (old_li->li_grmode >= DLM_LOCK_PW)
 549                         flags |= DLM_LKF_IVVALBLK;
 550
 551                 status = dlm_unlock(f->fi_ls->ls_lockspace,
 552                                     old_li->li_lksb.sb_lkid, flags,
 553                                     &li.li_lksb, &li);
 554
 555                 /* Must wait for it to complete as the next lock could be its
 556                  * parent */
 557                 if (status == 0)
 558                         wait_for_ast(&li);
 559
 560                 /* Unlock suceeded, free the lock_info struct. */
 561                 if (status == 0)
 562                         release_lockinfo(old_li);
 563         }
 564
 565         remove_wait_queue(&li.li_waitq, &wq);
 566
 567         /*
 568          * If this is the last reference to the lockspace
 569          * then free the struct. If it's an AUTOFREE lockspace
 570          * then free the whole thing.
 571          */
 572         mutex_lock(&user_ls_lock);
 573         if (atomic_dec_and_test(&lsinfo->ls_refcnt)) {
 574
 575                 if (lsinfo->ls_lockspace) {
 576                         if (test_bit(LS_FLAG_AUTOFREE, &lsinfo->ls_flags)) {
 577                                 unregister_lockspace(lsinfo, 1);
 578                         }
 579                 } else {
 580                         kfree(lsinfo->ls_miscinfo.name);
 581                         kfree(lsinfo);
 582                 }
 583         }
 584         mutex_unlock(&user_ls_lock);
 585         put_file_info(f);
 586
 587         /* Restore signals */
 588         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
 589         recalc_sigpending();
 590
 591         return 0;
 592 }
 593
 594 static int do_user_create_lockspace(struct file_info *fi, uint8_t cmd,
 595                                     struct dlm_lspace_params *kparams)
 596 {
 597         int status;
 598         struct user_ls *lsinfo;
 599
 600         if (!capable(CAP_SYS_ADMIN))
 601                 return -EPERM;
 602
 603         status = register_lockspace(kparams->name, &lsinfo, kparams->flags);
 604
 605         /* If it succeeded then return the minor number */
 606         if (status == 0)
 607                 status = lsinfo->ls_miscinfo.minor;
 608
 609         return status;
 610 }
 611
 612 static int do_user_remove_lockspace(struct file_info *fi, uint8_t cmd,
 613                                     struct dlm_lspace_params *kparams)
 614 {
 615         int status;
 616         int force = 1;
 617         struct user_ls *lsinfo;
 618
 619         if (!capable(CAP_SYS_ADMIN))
 620                 return -EPERM;
 621
 622         mutex_lock(&user_ls_lock);
 623         lsinfo = __find_lockspace(kparams->minor);
 624         if (!lsinfo) {
 625                 mutex_unlock(&user_ls_lock);
 626                 return -EINVAL;
 627         }
 628
 629         if (kparams->flags & DLM_USER_LSFLG_FORCEFREE)
 630                 force = 2;
 631
 632         status = unregister_lockspace(lsinfo, force);
 633         mutex_unlock(&user_ls_lock);
 634
 635         return status;
 636 }
 637
 638 /* Read call, might block if no ASTs are waiting.
 639  * It will only ever return one message at a time, regardless
 640  * of how many are pending.
 641  */
 642 static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count,
 643                         loff_t *ppos)
 644 {
 645         struct file_info *fi = file->private_data;
 646         struct ast_info *ast;
 647         int data_size;
 648         int offset;
 649         DECLARE_WAITQUEUE(wait, current);
 650
 651         if (count < sizeof(struct dlm_lock_result))
 652                 return -EINVAL;
 653
 654         spin_lock(&fi->fi_ast_lock);
 655         if (list_empty(&fi->fi_ast_list)) {
 656
 657                 /* No waiting ASTs.
 658                  * Return EOF if the lockspace been deleted.
 659                  */
 660                 if (test_bit(LS_FLAG_DELETED, &fi->fi_ls->ls_flags))
 661                         return 0;
 662
 663                 if (file->f_flags & O_NONBLOCK) {
 664                         spin_unlock(&fi->fi_ast_lock);
 665                         return -EAGAIN;
 666                 }
 667
 668                 add_wait_queue(&fi->fi_wait, &wait);
 669
 670         repeat:
 671                 set_current_state(TASK_INTERRUPTIBLE);
 672                 if (list_empty(&fi->fi_ast_list) &&
 673                     !signal_pending(current)) {
 674
 675                         spin_unlock(&fi->fi_ast_lock);
 676                         schedule();
 677                         spin_lock(&fi->fi_ast_lock);
 678                         goto repeat;
 679                 }
 680
 681                 current->state = TASK_RUNNING;
 682                 remove_wait_queue(&fi->fi_wait, &wait);
 683
 684                 if (signal_pending(current)) {
 685                         spin_unlock(&fi->fi_ast_lock);
 686                         return -ERESTARTSYS;
 687                 }
 688         }
 689
 690         ast = list_entry(fi->fi_ast_list.next, struct ast_info, list);
 691         list_del(&ast->list);
 692         spin_unlock(&fi->fi_ast_lock);
 693
 694         /* Work out the size of the returned data */
 695         data_size = sizeof(struct dlm_lock_result);
 696         if (ast->lvb_updated && ast->result.lksb.sb_lvbptr)
 697                 data_size += DLM_USER_LVB_LEN;
 698
 699         offset = sizeof(struct dlm_lock_result);
 700
 701         /* Room for the extended data ? */
 702         if (count >= data_size) {
 703
 704                 if (ast->lvb_updated && ast->result.lksb.sb_lvbptr) {
 705                         if (copy_to_user(buffer+offset,
 706                                          ast->result.lksb.sb_lvbptr,
 707                                          DLM_USER_LVB_LEN))
 708                                 return -EFAULT;
 709                         ast->result.lvb_offset = offset;
 710                         offset += DLM_USER_LVB_LEN;
 711                 }
 712         }
 713
 714         ast->result.length = data_size;
 715         /* Copy the header now it has all the offsets in it */
 716         if (copy_to_user(buffer, &ast->result, sizeof(struct dlm_lock_result)))
 717                 offset = -EFAULT;
 718
 719         /* If we only returned a header and there's more to come then put it
 720            back on the list */
 721         if (count < data_size) {
 722                 spin_lock(&fi->fi_ast_lock);
 723                 list_add(&ast->list, &fi->fi_ast_list);
 724                 spin_unlock(&fi->fi_ast_lock);
 725         } else
 726                 kfree(ast);
 727         return offset;
 728 }
 729
 730 static unsigned int dlm_poll(struct file *file, poll_table *wait)
 731 {
 732         struct file_info *fi = file->private_data;
 733
 734         poll_wait(file, &fi->fi_wait, wait);
 735
 736         spin_lock(&fi->fi_ast_lock);
 737         if (!list_empty(&fi->fi_ast_list)) {
 738                 spin_unlock(&fi->fi_ast_lock);
 739                 return POLLIN | POLLRDNORM;
 740         }
 741
 742         spin_unlock(&fi->fi_ast_lock);
 743         return 0;
 744 }
 745
 746 static struct lock_info *allocate_lockinfo(struct file_info *fi, uint8_t cmd,
 747                                            struct dlm_lock_params *kparams)
 748 {
 749         struct lock_info *li;
 750
 751         if (!try_module_get(THIS_MODULE))
 752                 return NULL;
 753
 754         li = kzalloc(sizeof(struct lock_info), GFP_KERNEL);
 755         if (li) {
 756                 li->li_magic     = LOCKINFO_MAGIC;
 757                 li->li_file      = fi;
 758                 li->li_cmd       = cmd;
 759                 li->li_flags     = 0;
 760                 li->li_grmode    = -1;
 761                 li->li_rqmode    = -1;
 762                 li->li_pend_bastparam = NULL;
 763                 li->li_pend_bastaddr  = NULL;
 764                 li->li_castaddr   = NULL;
 765                 li->li_castparam  = NULL;
 766                 li->li_lksb.sb_lvbptr = NULL;
 767                 li->li_bastaddr  = kparams->bastaddr;
 768                 li->li_bastparam = kparams->bastparam;
 769
 770                 get_file_info(fi);
 771         }
 772         return li;
 773 }
 774
 775 static int do_user_lock(struct file_info *fi, uint8_t cmd,
 776                         struct dlm_lock_params *kparams)
 777 {
 778         struct lock_info *li;
 779         int status;
 780
 781         /*
 782          * Validate things that we need to have correct.
 783          */
 784         if (!kparams->castaddr)
 785                 return -EINVAL;
 786
 787         if (!kparams->lksb)
 788                 return -EINVAL;
 789
 790         /* Persistent child locks are not available yet */
 791         if ((kparams->flags & DLM_LKF_PERSISTENT) && kparams->parent)
 792                 return -EINVAL;
 793
 794         /* For conversions, there should already be a lockinfo struct,
 795            unless we are adopting an orphaned persistent lock */
 796         if (kparams->flags & DLM_LKF_CONVERT) {
 797
 798                 li = get_lockinfo(kparams->lkid);
 799
 800                 /* If this is a persistent lock we will have to create a
 801                    lockinfo again */
 802                 if (!li && (kparams->flags & DLM_LKF_PERSISTENT)) {
 803                         li = allocate_lockinfo(fi, cmd, kparams);
 804                         if (!li)
 805                                 return -ENOMEM;
 806
 807                         li->li_lksb.sb_lkid = kparams->lkid;
 808                         li->li_castaddr  = kparams->castaddr;
 809                         li->li_castparam = kparams->castparam;
 810
 811                         /* OK, this isn;t exactly a FIRSTLOCK but it is the
 812                            first time we've used this lockinfo, and if things
 813                            fail we want rid of it */
 814                         init_MUTEX_LOCKED(&li->li_firstlock);
 815                         set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
 816                         add_lockinfo(li);
 817
 818                         /* TODO: do a query to get the current state ?? */
 819                 }
 820                 if (!li)
 821                         return -EINVAL;
 822
 823                 if (li->li_magic != LOCKINFO_MAGIC)
 824                         return -EINVAL;
 825
 826                 /* For conversions don't overwrite the current blocking AST
 827                    info so that:
 828                    a) if a blocking AST fires before the conversion is queued
 829                       it runs the current handler
 830                    b) if the conversion is cancelled, the original blocking AST
 831                       declaration is active
 832                    The pend_ info is made active when the conversion
 833                    completes.
 834                 */
 835                 li->li_pend_bastaddr  = kparams->bastaddr;
 836                 li->li_pend_bastparam = kparams->bastparam;
 837         } else {
 838                 li = allocate_lockinfo(fi, cmd, kparams);
 839                 if (!li)
 840                         return -ENOMEM;
 841
 842                 /* semaphore to allow us to complete our work before
 843                    the AST routine runs. In fact we only need (and use) this
 844                    when the initial lock fails */
 845                 init_MUTEX_LOCKED(&li->li_firstlock);
 846                 set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
 847         }
 848
 849         li->li_user_lksb = kparams->lksb;
 850         li->li_castaddr  = kparams->castaddr;
 851         li->li_castparam = kparams->castparam;
 852         li->li_lksb.sb_lkid = kparams->lkid;
 853         li->li_rqmode    = kparams->mode;
 854         if (kparams->flags & DLM_LKF_PERSISTENT)
 855                 set_bit(LI_FLAG_PERSISTENT, &li->li_flags);
 856
 857         /* Copy in the value block */
 858         if (kparams->flags & DLM_LKF_VALBLK) {
 859                 if (!li->li_lksb.sb_lvbptr) {
 860                         li->li_lksb.sb_lvbptr = kmalloc(DLM_USER_LVB_LEN,
 861                                                         GFP_KERNEL);
 862                         if (!li->li_lksb.sb_lvbptr) {
 863                                 status = -ENOMEM;
 864                                 goto out_err;
 865                         }
 866                 }
 867
 868                 memcpy(li->li_lksb.sb_lvbptr, kparams->lvb, DLM_USER_LVB_LEN);
 869         }
 870
 871         /* Lock it ... */
 872         status = dlm_lock(fi->fi_ls->ls_lockspace,
 873                           kparams->mode, &li->li_lksb,
 874                           kparams->flags,
 875                           kparams->name, kparams->namelen,
 876                           kparams->parent,
 877                           ast_routine,
 878                           li,
 879                           (li->li_pend_bastaddr || li->li_bastaddr) ?
 880                            bast_routine : 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                 set_bit(LI_FLAG_ONLIST, &li->li_flags);
 891                 spin_unlock(&fi->fi_li_lock);
 892                 if (add_lockinfo(li))
 893                         printk(KERN_WARNING "Add lockinfo failed\n");
 894
 895                 up(&li->li_firstlock);
 896         }
 897
 898         /* Return the lockid as the user needs it /now/ */
 899         return li->li_lksb.sb_lkid;
 900
 901  out_err:
 902         if (test_bit(LI_FLAG_FIRSTLOCK, &li->li_flags))
 903                 release_lockinfo(li);
 904         return status;
 905
 906 }
 907
 908 static int do_user_unlock(struct file_info *fi, uint8_t cmd,
 909                           struct dlm_lock_params *kparams)
 910 {
 911         struct lock_info *li;
 912         int status;
 913         int convert_cancel = 0;
 914
 915         li = get_lockinfo(kparams->lkid);
 916         if (!li) {
 917                 li = allocate_lockinfo(fi, cmd, kparams);
 918                 if (!li)
 919                         return -ENOMEM;
 920                 spin_lock(&fi->fi_li_lock);
 921                 list_add(&li->li_ownerqueue, &fi->fi_li_list);
 922                 set_bit(LI_FLAG_ONLIST, &li->li_flags);
 923                 spin_unlock(&fi->fi_li_lock);
 924         }
 925
 926         if (li->li_magic != LOCKINFO_MAGIC)
 927                 return -EINVAL;
 928
 929         li->li_user_lksb = kparams->lksb;
 930         li->li_castparam = kparams->castparam;
 931         li->li_cmd       = cmd;
 932
 933         /* Cancelling a conversion doesn't remove the lock...*/
 934         if (kparams->flags & DLM_LKF_CANCEL && li->li_grmode != -1)
 935                 convert_cancel = 1;
 936
 937         /* Wait until dlm_lock() has completed */
 938         if (!test_bit(LI_FLAG_ONLIST, &li->li_flags)) {
 939                 down(&li->li_firstlock);
 940                 up(&li->li_firstlock);
 941         }
 942
 943         /* dlm_unlock() passes a 0 for castaddr which means don't overwrite
 944            the existing li_castaddr as that's the completion routine for
 945            unlocks. dlm_unlock_wait() specifies a new AST routine to be
 946            executed when the unlock completes. */
 947         if (kparams->castaddr)
 948                 li->li_castaddr = kparams->castaddr;
 949
 950         /* Use existing lksb & astparams */
 951         status = dlm_unlock(fi->fi_ls->ls_lockspace,
 952                              kparams->lkid,
 953                              kparams->flags, &li->li_lksb, li);
 954
 955         if (!status && !convert_cancel) {
 956                 spin_lock(&fi->fi_li_lock);
 957                 list_del(&li->li_ownerqueue);
 958                 clear_bit(LI_FLAG_ONLIST, &li->li_flags);
 959                 spin_unlock(&fi->fi_li_lock);
 960         }
 961
 962         return status;
 963 }
 964
 965 /* Write call, submit a locking request */
 966 static ssize_t dlm_write(struct file *file, const char __user *buffer,
 967                          size_t count, loff_t *ppos)
 968 {
 969         struct file_info *fi = file->private_data;
 970         struct dlm_write_request *kparams;
 971         sigset_t tmpsig;
 972         sigset_t allsigs;
 973         int status;
 974
 975         /* -1 because lock name is optional */
 976         if (count < sizeof(struct dlm_write_request)-1)
 977                 return -EINVAL;
 978
 979         /* Has the lockspace been deleted */
 980         if (fi && test_bit(LS_FLAG_DELETED, &fi->fi_ls->ls_flags))
 981                 return -ENOENT;
 982
 983         kparams = kmalloc(count, GFP_KERNEL);
 984         if (!kparams)
 985                 return -ENOMEM;
 986
 987         status = -EFAULT;
 988         /* Get the command info */
 989         if (copy_from_user(kparams, buffer, count))
 990                 goto out_free;
 991
 992         status = -EBADE;
 993         if (check_version(kparams))
 994                 goto out_free;
 995
 996         /* Block signals while we are doing this */
 997         sigfillset(&allsigs);
 998         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
 999
1000         status = -EINVAL;
1001         switch (kparams->cmd)
1002         {
1003         case DLM_USER_LOCK:
1004                 if (!fi) goto out_sig;
1005                 status = do_user_lock(fi, kparams->cmd, &kparams->i.lock);
1006                 break;
1007
1008         case DLM_USER_UNLOCK:
1009                 if (!fi) goto out_sig;
1010                 status = do_user_unlock(fi, kparams->cmd, &kparams->i.lock);
1011                 break;
1012
1013         case DLM_USER_CREATE_LOCKSPACE:
1014                 if (fi) goto out_sig;
1015                 status = do_user_create_lockspace(fi, kparams->cmd,
1016                                                   &kparams->i.lspace);
1017                 break;
1018
1019         case DLM_USER_REMOVE_LOCKSPACE:
1020                 if (fi) goto out_sig;
1021                 status = do_user_remove_lockspace(fi, kparams->cmd,
1022                                                   &kparams->i.lspace);
1023                 break;
1024         default:
1025                 printk("Unknown command passed to DLM device : %d\n",
1026                         kparams->cmd);
1027                 break;
1028         }
1029
1030  out_sig:
1031         /* Restore signals */
1032         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
1033         recalc_sigpending();
1034
1035  out_free:
1036         kfree(kparams);
1037         if (status == 0)
1038                 return count;
1039         else
1040                 return status;
1041 }
1042
1043 static struct file_operations _dlm_fops = {
1044       .open    = dlm_open,
1045       .release = dlm_close,
1046       .read    = dlm_read,
1047       .write   = dlm_write,
1048       .poll    = dlm_poll,
1049       .owner   = THIS_MODULE,
1050 };
1051
1052 static struct file_operations _dlm_ctl_fops = {
1053       .open    = dlm_ctl_open,
1054       .release = dlm_ctl_close,
1055       .write   = dlm_write,
1056       .owner   = THIS_MODULE,
1057 };
1058
1059 /*
1060  * Create control device
1061  */
1062 static int __init dlm_device_init(void)
1063 {
1064         int r;
1065
1066         INIT_LIST_HEAD(&user_ls_list);
1067         mutex_init(&user_ls_lock);
1068         rwlock_init(&lockinfo_lock);
1069
1070         ctl_device.name = "dlm-control";
1071         ctl_device.fops = &_dlm_ctl_fops;
1072         ctl_device.minor = MISC_DYNAMIC_MINOR;
1073
1074         r = misc_register(&ctl_device);
1075         if (r) {
1076                 printk(KERN_ERR "dlm: misc_register failed for control dev\n");
1077                 return r;
1078         }
1079
1080         return 0;
1081 }
1082
1083 static void __exit dlm_device_exit(void)
1084 {
1085         misc_deregister(&ctl_device);
1086 }
1087
1088 MODULE_DESCRIPTION("Distributed Lock Manager device interface");
1089 MODULE_AUTHOR("Red Hat, Inc.");
1090 MODULE_LICENSE("GPL");
1091
1092 module_init(dlm_device_init);
1093 module_exit(dlm_device_exit);