fs/dlm/user.c

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