SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/dlm/user.c

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