fs/dlm/user.c

   1 /*
   2  * Copyright (C) 2006-2010 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/file.h>
  13 #include <linux/fs.h>
  14 #include <linux/poll.h>
  15 #include <linux/signal.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/dlm.h>
  18 #include <linux/dlm_device.h>
  19 #include <linux/slab.h>
  20 #include <linux/sched/signal.h>
  21
  22 #include "dlm_internal.h"
  23 #include "lockspace.h"
  24 #include "lock.h"
  25 #include "lvb_table.h"
  26 #include "user.h"
  27 #include "ast.h"
  28
  29 static const char name_prefix[] = "dlm";
  30 static const struct file_operations device_fops;
  31 static atomic_t dlm_monitor_opened;
  32 static int dlm_monitor_unused = 1;
  33
  34 #ifdef CONFIG_COMPAT
  35
  36 struct dlm_lock_params32 {
  37         __u8 mode;
  38         __u8 namelen;
  39         __u16 unused;
  40         __u32 flags;
  41         __u32 lkid;
  42         __u32 parent;
  43         __u64 xid;
  44         __u64 timeout;
  45         __u32 castparam;
  46         __u32 castaddr;
  47         __u32 bastparam;
  48         __u32 bastaddr;
  49         __u32 lksb;
  50         char lvb[DLM_USER_LVB_LEN];
  51         char name[0];
  52 };
  53
  54 struct dlm_write_request32 {
  55         __u32 version[3];
  56         __u8 cmd;
  57         __u8 is64bit;
  58         __u8 unused[2];
  59
  60         union  {
  61                 struct dlm_lock_params32 lock;
  62                 struct dlm_lspace_params lspace;
  63                 struct dlm_purge_params purge;
  64         } i;
  65 };
  66
  67 struct dlm_lksb32 {
  68         __u32 sb_status;
  69         __u32 sb_lkid;
  70         __u8 sb_flags;
  71         __u32 sb_lvbptr;
  72 };
  73
  74 struct dlm_lock_result32 {
  75         __u32 version[3];
  76         __u32 length;
  77         __u32 user_astaddr;
  78         __u32 user_astparam;
  79         __u32 user_lksb;
  80         struct dlm_lksb32 lksb;
  81         __u8 bast_mode;
  82         __u8 unused[3];
  83         /* Offsets may be zero if no data is present */
  84         __u32 lvb_offset;
  85 };
  86
  87 static void compat_input(struct dlm_write_request *kb,
  88                          struct dlm_write_request32 *kb32,
  89                          int namelen)
  90 {
  91         kb->version[0] = kb32->version[0];
  92         kb->version[1] = kb32->version[1];
  93         kb->version[2] = kb32->version[2];
  94
  95         kb->cmd = kb32->cmd;
  96         kb->is64bit = kb32->is64bit;
  97         if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
  98             kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
  99                 kb->i.lspace.flags = kb32->i.lspace.flags;
 100                 kb->i.lspace.minor = kb32->i.lspace.minor;
 101                 memcpy(kb->i.lspace.name, kb32->i.lspace.name, namelen);
 102         } else if (kb->cmd == DLM_USER_PURGE) {
 103                 kb->i.purge.nodeid = kb32->i.purge.nodeid;
 104                 kb->i.purge.pid = kb32->i.purge.pid;
 105         } else {
 106                 kb->i.lock.mode = kb32->i.lock.mode;
 107                 kb->i.lock.namelen = kb32->i.lock.namelen;
 108                 kb->i.lock.flags = kb32->i.lock.flags;
 109                 kb->i.lock.lkid = kb32->i.lock.lkid;
 110                 kb->i.lock.parent = kb32->i.lock.parent;
 111                 kb->i.lock.xid = kb32->i.lock.xid;
 112                 kb->i.lock.timeout = kb32->i.lock.timeout;
 113                 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
 114                 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
 115                 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
 116                 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
 117                 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
 118                 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
 119                 memcpy(kb->i.lock.name, kb32->i.lock.name, namelen);
 120         }
 121 }
 122
 123 static void compat_output(struct dlm_lock_result *res,
 124                           struct dlm_lock_result32 *res32)
 125 {
 126         memset(res32, 0, sizeof(*res32));
 127
 128         res32->version[0] = res->version[0];
 129         res32->version[1] = res->version[1];
 130         res32->version[2] = res->version[2];
 131
 132         res32->user_astaddr = (__u32)(long)res->user_astaddr;
 133         res32->user_astparam = (__u32)(long)res->user_astparam;
 134         res32->user_lksb = (__u32)(long)res->user_lksb;
 135         res32->bast_mode = res->bast_mode;
 136
 137         res32->lvb_offset = res->lvb_offset;
 138         res32->length = res->length;
 139
 140         res32->lksb.sb_status = res->lksb.sb_status;
 141         res32->lksb.sb_flags = res->lksb.sb_flags;
 142         res32->lksb.sb_lkid = res->lksb.sb_lkid;
 143         res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
 144 }
 145 #endif
 146
 147 /* Figure out if this lock is at the end of its life and no longer
 148    available for the application to use.  The lkb still exists until
 149    the final ast is read.  A lock becomes EOL in three situations:
 150      1. a noqueue request fails with EAGAIN
 151      2. an unlock completes with EUNLOCK
 152      3. a cancel of a waiting request completes with ECANCEL/EDEADLK
 153    An EOL lock needs to be removed from the process's list of locks.
 154    And we can't allow any new operation on an EOL lock.  This is
 155    not related to the lifetime of the lkb struct which is managed
 156    entirely by refcount. */
 157
 158 static int lkb_is_endoflife(int mode, int status)
 159 {
 160         switch (status) {
 161         case -DLM_EUNLOCK:
 162                 return 1;
 163         case -DLM_ECANCEL:
 164         case -ETIMEDOUT:
 165         case -EDEADLK:
 166         case -EAGAIN:
 167                 if (mode == DLM_LOCK_IV)
 168                         return 1;
 169                 break;
 170         }
 171         return 0;
 172 }
 173
 174 /* we could possibly check if the cancel of an orphan has resulted in the lkb
 175    being removed and then remove that lkb from the orphans list and free it */
 176
 177 void dlm_user_add_ast(struct dlm_lkb *lkb, uint32_t flags, int mode,
 178                       int status, uint32_t sbflags, uint64_t seq)
 179 {
 180         struct dlm_ls *ls;
 181         struct dlm_user_args *ua;
 182         struct dlm_user_proc *proc;
 183         int rv;
 184
 185         if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
 186                 return;
 187
 188         ls = lkb->lkb_resource->res_ls;
 189         mutex_lock(&ls->ls_clear_proc_locks);
 190
 191         /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
 192            can't be delivered.  For ORPHAN's, dlm_clear_proc_locks() freed
 193            lkb->ua so we can't try to use it.  This second check is necessary
 194            for cases where a completion ast is received for an operation that
 195            began before clear_proc_locks did its cancel/unlock. */
 196
 197         if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
 198                 goto out;
 199
 200         DLM_ASSERT(lkb->lkb_ua, dlm_print_lkb(lkb););
 201         ua = lkb->lkb_ua;
 202         proc = ua->proc;
 203
 204         if ((flags & DLM_CB_BAST) && ua->bastaddr == NULL)
 205                 goto out;
 206
 207         if ((flags & DLM_CB_CAST) && lkb_is_endoflife(mode, status))
 208                 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE;
 209
 210         spin_lock(&proc->asts_spin);
 211
 212         rv = dlm_add_lkb_callback(lkb, flags, mode, status, sbflags, seq);
 213         if (rv < 0) {
 214                 spin_unlock(&proc->asts_spin);
 215                 goto out;
 216         }
 217
 218         if (list_empty(&lkb->lkb_cb_list)) {
 219                 kref_get(&lkb->lkb_ref);
 220                 list_add_tail(&lkb->lkb_cb_list, &proc->asts);
 221                 wake_up_interruptible(&proc->wait);
 222         }
 223         spin_unlock(&proc->asts_spin);
 224
 225         if (lkb->lkb_flags & DLM_IFL_ENDOFLIFE) {
 226                 /* N.B. spin_lock locks_spin, not asts_spin */
 227                 spin_lock(&proc->locks_spin);
 228                 if (!list_empty(&lkb->lkb_ownqueue)) {
 229                         list_del_init(&lkb->lkb_ownqueue);
 230                         dlm_put_lkb(lkb);
 231                 }
 232                 spin_unlock(&proc->locks_spin);
 233         }
 234  out:
 235         mutex_unlock(&ls->ls_clear_proc_locks);
 236 }
 237
 238 static int device_user_lock(struct dlm_user_proc *proc,
 239                             struct dlm_lock_params *params)
 240 {
 241         struct dlm_ls *ls;
 242         struct dlm_user_args *ua;
 243         uint32_t lkid;
 244         int error = -ENOMEM;
 245
 246         ls = dlm_find_lockspace_local(proc->lockspace);
 247         if (!ls)
 248                 return -ENOENT;
 249
 250         if (!params->castaddr || !params->lksb) {
 251                 error = -EINVAL;
 252                 goto out;
 253         }
 254
 255         ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
 256         if (!ua)
 257                 goto out;
 258         ua->proc = proc;
 259         ua->user_lksb = params->lksb;
 260         ua->castparam = params->castparam;
 261         ua->castaddr = params->castaddr;
 262         ua->bastparam = params->bastparam;
 263         ua->bastaddr = params->bastaddr;
 264         ua->xid = params->xid;
 265
 266         if (params->flags & DLM_LKF_CONVERT) {
 267                 error = dlm_user_convert(ls, ua,
 268                                          params->mode, params->flags,
 269                                          params->lkid, params->lvb,
 270                                          (unsigned long) params->timeout);
 271         } else if (params->flags & DLM_LKF_ORPHAN) {
 272                 error = dlm_user_adopt_orphan(ls, ua,
 273                                          params->mode, params->flags,
 274                                          params->name, params->namelen,
 275                                          (unsigned long) params->timeout,
 276                                          &lkid);
 277                 if (!error)
 278                         error = lkid;
 279         } else {
 280                 error = dlm_user_request(ls, ua,
 281                                          params->mode, params->flags,
 282                                          params->name, params->namelen,
 283                                          (unsigned long) params->timeout);
 284                 if (!error)
 285                         error = ua->lksb.sb_lkid;
 286         }
 287  out:
 288         dlm_put_lockspace(ls);
 289         return error;
 290 }
 291
 292 static int device_user_unlock(struct dlm_user_proc *proc,
 293                               struct dlm_lock_params *params)
 294 {
 295         struct dlm_ls *ls;
 296         struct dlm_user_args *ua;
 297         int error = -ENOMEM;
 298
 299         ls = dlm_find_lockspace_local(proc->lockspace);
 300         if (!ls)
 301                 return -ENOENT;
 302
 303         ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
 304         if (!ua)
 305                 goto out;
 306         ua->proc = proc;
 307         ua->user_lksb = params->lksb;
 308         ua->castparam = params->castparam;
 309         ua->castaddr = params->castaddr;
 310
 311         if (params->flags & DLM_LKF_CANCEL)
 312                 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
 313         else
 314                 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
 315                                         params->lvb);
 316  out:
 317         dlm_put_lockspace(ls);
 318         return error;
 319 }
 320
 321 static int device_user_deadlock(struct dlm_user_proc *proc,
 322                                 struct dlm_lock_params *params)
 323 {
 324         struct dlm_ls *ls;
 325         int error;
 326
 327         ls = dlm_find_lockspace_local(proc->lockspace);
 328         if (!ls)
 329                 return -ENOENT;
 330
 331         error = dlm_user_deadlock(ls, params->flags, params->lkid);
 332
 333         dlm_put_lockspace(ls);
 334         return error;
 335 }
 336
 337 static int dlm_device_register(struct dlm_ls *ls, char *name)
 338 {
 339         int error, len;
 340
 341         /* The device is already registered.  This happens when the
 342            lockspace is created multiple times from userspace. */
 343         if (ls->ls_device.name)
 344                 return 0;
 345
 346         error = -ENOMEM;
 347         len = strlen(name) + strlen(name_prefix) + 2;
 348         ls->ls_device.name = kzalloc(len, GFP_NOFS);
 349         if (!ls->ls_device.name)
 350                 goto fail;
 351
 352         snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
 353                  name);
 354         ls->ls_device.fops = &device_fops;
 355         ls->ls_device.minor = MISC_DYNAMIC_MINOR;
 356
 357         error = misc_register(&ls->ls_device);
 358         if (error) {
 359                 kfree(ls->ls_device.name);
 360                 /* this has to be set to NULL
 361                  * to avoid a double-free in dlm_device_deregister
 362                  */
 363                 ls->ls_device.name = NULL;
 364         }
 365 fail:
 366         return error;
 367 }
 368
 369 int dlm_device_deregister(struct dlm_ls *ls)
 370 {
 371         /* The device is not registered.  This happens when the lockspace
 372            was never used from userspace, or when device_create_lockspace()
 373            calls dlm_release_lockspace() after the register fails. */
 374         if (!ls->ls_device.name)
 375                 return 0;
 376
 377         misc_deregister(&ls->ls_device);
 378         kfree(ls->ls_device.name);
 379         return 0;
 380 }
 381
 382 static int device_user_purge(struct dlm_user_proc *proc,
 383                              struct dlm_purge_params *params)
 384 {
 385         struct dlm_ls *ls;
 386         int error;
 387
 388         ls = dlm_find_lockspace_local(proc->lockspace);
 389         if (!ls)
 390                 return -ENOENT;
 391
 392         error = dlm_user_purge(ls, proc, params->nodeid, params->pid);
 393
 394         dlm_put_lockspace(ls);
 395         return error;
 396 }
 397
 398 static int device_create_lockspace(struct dlm_lspace_params *params)
 399 {
 400         dlm_lockspace_t *lockspace;
 401         struct dlm_ls *ls;
 402         int error;
 403
 404         if (!capable(CAP_SYS_ADMIN))
 405                 return -EPERM;
 406
 407         error = dlm_new_lockspace(params->name, NULL, params->flags,
 408                                   DLM_USER_LVB_LEN, NULL, NULL, NULL,
 409                                   &lockspace);
 410         if (error)
 411                 return error;
 412
 413         ls = dlm_find_lockspace_local(lockspace);
 414         if (!ls)
 415                 return -ENOENT;
 416
 417         error = dlm_device_register(ls, params->name);
 418         dlm_put_lockspace(ls);
 419
 420         if (error)
 421                 dlm_release_lockspace(lockspace, 0);
 422         else
 423                 error = ls->ls_device.minor;
 424
 425         return error;
 426 }
 427
 428 static int device_remove_lockspace(struct dlm_lspace_params *params)
 429 {
 430         dlm_lockspace_t *lockspace;
 431         struct dlm_ls *ls;
 432         int error, force = 0;
 433
 434         if (!capable(CAP_SYS_ADMIN))
 435                 return -EPERM;
 436
 437         ls = dlm_find_lockspace_device(params->minor);
 438         if (!ls)
 439                 return -ENOENT;
 440
 441         if (params->flags & DLM_USER_LSFLG_FORCEFREE)
 442                 force = 2;
 443
 444         lockspace = ls->ls_local_handle;
 445         dlm_put_lockspace(ls);
 446
 447         /* The final dlm_release_lockspace waits for references to go to
 448            zero, so all processes will need to close their device for the
 449            ls before the release will proceed.  release also calls the
 450            device_deregister above.  Converting a positive return value
 451            from release to zero means that userspace won't know when its
 452            release was the final one, but it shouldn't need to know. */
 453
 454         error = dlm_release_lockspace(lockspace, force);
 455         if (error > 0)
 456                 error = 0;
 457         return error;
 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                        task_pid_nr(current),
 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 /*
 483  * device_write
 484  *
 485  *   device_user_lock
 486  *     dlm_user_request -> request_lock
 487  *     dlm_user_convert -> convert_lock
 488  *
 489  *   device_user_unlock
 490  *     dlm_user_unlock -> unlock_lock
 491  *     dlm_user_cancel -> cancel_lock
 492  *
 493  *   device_create_lockspace
 494  *     dlm_new_lockspace
 495  *
 496  *   device_remove_lockspace
 497  *     dlm_release_lockspace
 498  */
 499
 500 /* a write to a lockspace device is a lock or unlock request, a write
 501    to the control device is to create/remove a lockspace */
 502
 503 static ssize_t device_write(struct file *file, const char __user *buf,
 504                             size_t count, loff_t *ppos)
 505 {
 506         struct dlm_user_proc *proc = file->private_data;
 507         struct dlm_write_request *kbuf;
 508         int error;
 509
 510 #ifdef CONFIG_COMPAT
 511         if (count < sizeof(struct dlm_write_request32))
 512 #else
 513         if (count < sizeof(struct dlm_write_request))
 514 #endif
 515                 return -EINVAL;
 516
 517         /*
 518          * can't compare against COMPAT/dlm_write_request32 because
 519          * we don't yet know if is64bit is zero
 520          */
 521         if (count > sizeof(struct dlm_write_request) + DLM_RESNAME_MAXLEN)
 522                 return -EINVAL;
 523
 524         kbuf = memdup_user_nul(buf, count);
 525         if (IS_ERR(kbuf))
 526                 return PTR_ERR(kbuf);
 527
 528         if (check_version(kbuf)) {
 529                 error = -EBADE;
 530                 goto out_free;
 531         }
 532
 533 #ifdef CONFIG_COMPAT
 534         if (!kbuf->is64bit) {
 535                 struct dlm_write_request32 *k32buf;
 536                 int namelen = 0;
 537
 538                 if (count > sizeof(struct dlm_write_request32))
 539                         namelen = count - sizeof(struct dlm_write_request32);
 540
 541                 k32buf = (struct dlm_write_request32 *)kbuf;
 542
 543                 /* add 1 after namelen so that the name string is terminated */
 544                 kbuf = kzalloc(sizeof(struct dlm_write_request) + namelen + 1,
 545                                GFP_NOFS);
 546                 if (!kbuf) {
 547                         kfree(k32buf);
 548                         return -ENOMEM;
 549                 }
 550
 551                 if (proc)
 552                         set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
 553
 554                 compat_input(kbuf, k32buf, namelen);
 555                 kfree(k32buf);
 556         }
 557 #endif
 558
 559         /* do we really need this? can a write happen after a close? */
 560         if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
 561             (proc && test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))) {
 562                 error = -EINVAL;
 563                 goto out_free;
 564         }
 565
 566         error = -EINVAL;
 567
 568         switch (kbuf->cmd)
 569         {
 570         case DLM_USER_LOCK:
 571                 if (!proc) {
 572                         log_print("no locking on control device");
 573                         goto out_free;
 574                 }
 575                 error = device_user_lock(proc, &kbuf->i.lock);
 576                 break;
 577
 578         case DLM_USER_UNLOCK:
 579                 if (!proc) {
 580                         log_print("no locking on control device");
 581                         goto out_free;
 582                 }
 583                 error = device_user_unlock(proc, &kbuf->i.lock);
 584                 break;
 585
 586         case DLM_USER_DEADLOCK:
 587                 if (!proc) {
 588                         log_print("no locking on control device");
 589                         goto out_free;
 590                 }
 591                 error = device_user_deadlock(proc, &kbuf->i.lock);
 592                 break;
 593
 594         case DLM_USER_CREATE_LOCKSPACE:
 595                 if (proc) {
 596                         log_print("create/remove only on control device");
 597                         goto out_free;
 598                 }
 599                 error = device_create_lockspace(&kbuf->i.lspace);
 600                 break;
 601
 602         case DLM_USER_REMOVE_LOCKSPACE:
 603                 if (proc) {
 604                         log_print("create/remove only on control device");
 605                         goto out_free;
 606                 }
 607                 error = device_remove_lockspace(&kbuf->i.lspace);
 608                 break;
 609
 610         case DLM_USER_PURGE:
 611                 if (!proc) {
 612                         log_print("no locking on control device");
 613                         goto out_free;
 614                 }
 615                 error = device_user_purge(proc, &kbuf->i.purge);
 616                 break;
 617
 618         default:
 619                 log_print("Unknown command passed to DLM device : %d\n",
 620                           kbuf->cmd);
 621         }
 622
 623  out_free:
 624         kfree(kbuf);
 625         return error;
 626 }
 627
 628 /* Every process that opens the lockspace device has its own "proc" structure
 629    hanging off the open file that's used to keep track of locks owned by the
 630    process and asts that need to be delivered to the process. */
 631
 632 static int device_open(struct inode *inode, struct file *file)
 633 {
 634         struct dlm_user_proc *proc;
 635         struct dlm_ls *ls;
 636
 637         ls = dlm_find_lockspace_device(iminor(inode));
 638         if (!ls)
 639                 return -ENOENT;
 640
 641         proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS);
 642         if (!proc) {
 643                 dlm_put_lockspace(ls);
 644                 return -ENOMEM;
 645         }
 646
 647         proc->lockspace = ls->ls_local_handle;
 648         INIT_LIST_HEAD(&proc->asts);
 649         INIT_LIST_HEAD(&proc->locks);
 650         INIT_LIST_HEAD(&proc->unlocking);
 651         spin_lock_init(&proc->asts_spin);
 652         spin_lock_init(&proc->locks_spin);
 653         init_waitqueue_head(&proc->wait);
 654         file->private_data = proc;
 655
 656         return 0;
 657 }
 658
 659 static int device_close(struct inode *inode, struct file *file)
 660 {
 661         struct dlm_user_proc *proc = file->private_data;
 662         struct dlm_ls *ls;
 663
 664         ls = dlm_find_lockspace_local(proc->lockspace);
 665         if (!ls)
 666                 return -ENOENT;
 667
 668         set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
 669
 670         dlm_clear_proc_locks(ls, proc);
 671
 672         /* at this point no more lkb's should exist for this lockspace,
 673            so there's no chance of dlm_user_add_ast() being called and
 674            looking for lkb->ua->proc */
 675
 676         kfree(proc);
 677         file->private_data = NULL;
 678
 679         dlm_put_lockspace(ls);
 680         dlm_put_lockspace(ls);  /* for the find in device_open() */
 681
 682         /* FIXME: AUTOFREE: if this ls is no longer used do
 683            device_remove_lockspace() */
 684
 685         return 0;
 686 }
 687
 688 static int copy_result_to_user(struct dlm_user_args *ua, int compat,
 689                                uint32_t flags, int mode, int copy_lvb,
 690                                char __user *buf, size_t count)
 691 {
 692 #ifdef CONFIG_COMPAT
 693         struct dlm_lock_result32 result32;
 694 #endif
 695         struct dlm_lock_result result;
 696         void *resultptr;
 697         int error=0;
 698         int len;
 699         int struct_len;
 700
 701         memset(&result, 0, sizeof(struct dlm_lock_result));
 702         result.version[0] = DLM_DEVICE_VERSION_MAJOR;
 703         result.version[1] = DLM_DEVICE_VERSION_MINOR;
 704         result.version[2] = DLM_DEVICE_VERSION_PATCH;
 705         memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
 706         result.user_lksb = ua->user_lksb;
 707
 708         /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
 709            in a conversion unless the conversion is successful.  See code
 710            in dlm_user_convert() for updating ua from ua_tmp.  OpenVMS, though,
 711            notes that a new blocking AST address and parameter are set even if
 712            the conversion fails, so maybe we should just do that. */
 713
 714         if (flags & DLM_CB_BAST) {
 715                 result.user_astaddr = ua->bastaddr;
 716                 result.user_astparam = ua->bastparam;
 717                 result.bast_mode = mode;
 718         } else {
 719                 result.user_astaddr = ua->castaddr;
 720                 result.user_astparam = ua->castparam;
 721         }
 722
 723 #ifdef CONFIG_COMPAT
 724         if (compat)
 725                 len = sizeof(struct dlm_lock_result32);
 726         else
 727 #endif
 728                 len = sizeof(struct dlm_lock_result);
 729         struct_len = len;
 730
 731         /* copy lvb to userspace if there is one, it's been updated, and
 732            the user buffer has space for it */
 733
 734         if (copy_lvb && ua->lksb.sb_lvbptr && count >= len + DLM_USER_LVB_LEN) {
 735                 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
 736                                  DLM_USER_LVB_LEN)) {
 737                         error = -EFAULT;
 738                         goto out;
 739                 }
 740
 741                 result.lvb_offset = len;
 742                 len += DLM_USER_LVB_LEN;
 743         }
 744
 745         result.length = len;
 746         resultptr = &result;
 747 #ifdef CONFIG_COMPAT
 748         if (compat) {
 749                 compat_output(&result, &result32);
 750                 resultptr = &result32;
 751         }
 752 #endif
 753
 754         if (copy_to_user(buf, resultptr, struct_len))
 755                 error = -EFAULT;
 756         else
 757                 error = len;
 758  out:
 759         return error;
 760 }
 761
 762 static int copy_version_to_user(char __user *buf, size_t count)
 763 {
 764         struct dlm_device_version ver;
 765
 766         memset(&ver, 0, sizeof(struct dlm_device_version));
 767         ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
 768         ver.version[1] = DLM_DEVICE_VERSION_MINOR;
 769         ver.version[2] = DLM_DEVICE_VERSION_PATCH;
 770
 771         if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
 772                 return -EFAULT;
 773         return sizeof(struct dlm_device_version);
 774 }
 775
 776 /* a read returns a single ast described in a struct dlm_lock_result */
 777
 778 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
 779                            loff_t *ppos)
 780 {
 781         struct dlm_user_proc *proc = file->private_data;
 782         struct dlm_lkb *lkb;
 783         DECLARE_WAITQUEUE(wait, current);
 784         struct dlm_callback cb;
 785         int rv, resid, copy_lvb = 0;
 786         int old_mode, new_mode;
 787
 788         if (count == sizeof(struct dlm_device_version)) {
 789                 rv = copy_version_to_user(buf, count);
 790                 return rv;
 791         }
 792
 793         if (!proc) {
 794                 log_print("non-version read from control device %zu", count);
 795                 return -EINVAL;
 796         }
 797
 798 #ifdef CONFIG_COMPAT
 799         if (count < sizeof(struct dlm_lock_result32))
 800 #else
 801         if (count < sizeof(struct dlm_lock_result))
 802 #endif
 803                 return -EINVAL;
 804
 805  try_another:
 806
 807         /* do we really need this? can a read happen after a close? */
 808         if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
 809                 return -EINVAL;
 810
 811         spin_lock(&proc->asts_spin);
 812         if (list_empty(&proc->asts)) {
 813                 if (file->f_flags & O_NONBLOCK) {
 814                         spin_unlock(&proc->asts_spin);
 815                         return -EAGAIN;
 816                 }
 817
 818                 add_wait_queue(&proc->wait, &wait);
 819
 820         repeat:
 821                 set_current_state(TASK_INTERRUPTIBLE);
 822                 if (list_empty(&proc->asts) && !signal_pending(current)) {
 823                         spin_unlock(&proc->asts_spin);
 824                         schedule();
 825                         spin_lock(&proc->asts_spin);
 826                         goto repeat;
 827                 }
 828                 set_current_state(TASK_RUNNING);
 829                 remove_wait_queue(&proc->wait, &wait);
 830
 831                 if (signal_pending(current)) {
 832                         spin_unlock(&proc->asts_spin);
 833                         return -ERESTARTSYS;
 834                 }
 835         }
 836
 837         /* if we empty lkb_callbacks, we don't want to unlock the spinlock
 838            without removing lkb_cb_list; so empty lkb_cb_list is always
 839            consistent with empty lkb_callbacks */
 840
 841         lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_cb_list);
 842
 843         /* rem_lkb_callback sets a new lkb_last_cast */
 844         old_mode = lkb->lkb_last_cast.mode;
 845
 846         rv = dlm_rem_lkb_callback(lkb->lkb_resource->res_ls, lkb, &cb, &resid);
 847         if (rv < 0) {
 848                 /* this shouldn't happen; lkb should have been removed from
 849                    list when resid was zero */
 850                 log_print("dlm_rem_lkb_callback empty %x", lkb->lkb_id);
 851                 list_del_init(&lkb->lkb_cb_list);
 852                 spin_unlock(&proc->asts_spin);
 853                 /* removes ref for proc->asts, may cause lkb to be freed */
 854                 dlm_put_lkb(lkb);
 855                 goto try_another;
 856         }
 857         if (!resid)
 858                 list_del_init(&lkb->lkb_cb_list);
 859         spin_unlock(&proc->asts_spin);
 860
 861         if (cb.flags & DLM_CB_SKIP) {
 862                 /* removes ref for proc->asts, may cause lkb to be freed */
 863                 if (!resid)
 864                         dlm_put_lkb(lkb);
 865                 goto try_another;
 866         }
 867
 868         if (cb.flags & DLM_CB_CAST) {
 869                 new_mode = cb.mode;
 870
 871                 if (!cb.sb_status && lkb->lkb_lksb->sb_lvbptr &&
 872                     dlm_lvb_operations[old_mode + 1][new_mode + 1])
 873                         copy_lvb = 1;
 874
 875                 lkb->lkb_lksb->sb_status = cb.sb_status;
 876                 lkb->lkb_lksb->sb_flags = cb.sb_flags;
 877         }
 878
 879         rv = copy_result_to_user(lkb->lkb_ua,
 880                                  test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
 881                                  cb.flags, cb.mode, copy_lvb, buf, count);
 882
 883         /* removes ref for proc->asts, may cause lkb to be freed */
 884         if (!resid)
 885                 dlm_put_lkb(lkb);
 886
 887         return rv;
 888 }
 889
 890 static __poll_t device_poll(struct file *file, poll_table *wait)
 891 {
 892         struct dlm_user_proc *proc = file->private_data;
 893
 894         poll_wait(file, &proc->wait, wait);
 895
 896         spin_lock(&proc->asts_spin);
 897         if (!list_empty(&proc->asts)) {
 898                 spin_unlock(&proc->asts_spin);
 899                 return EPOLLIN | EPOLLRDNORM;
 900         }
 901         spin_unlock(&proc->asts_spin);
 902         return 0;
 903 }
 904
 905 int dlm_user_daemon_available(void)
 906 {
 907         /* dlm_controld hasn't started (or, has started, but not
 908            properly populated configfs) */
 909
 910         if (!dlm_our_nodeid())
 911                 return 0;
 912
 913         /* This is to deal with versions of dlm_controld that don't
 914            know about the monitor device.  We assume that if the
 915            dlm_controld was started (above), but the monitor device
 916            was never opened, that it's an old version.  dlm_controld
 917            should open the monitor device before populating configfs. */
 918
 919         if (dlm_monitor_unused)
 920                 return 1;
 921
 922         return atomic_read(&dlm_monitor_opened) ? 1 : 0;
 923 }
 924
 925 static int ctl_device_open(struct inode *inode, struct file *file)
 926 {
 927         file->private_data = NULL;
 928         return 0;
 929 }
 930
 931 static int ctl_device_close(struct inode *inode, struct file *file)
 932 {
 933         return 0;
 934 }
 935
 936 static int monitor_device_open(struct inode *inode, struct file *file)
 937 {
 938         atomic_inc(&dlm_monitor_opened);
 939         dlm_monitor_unused = 0;
 940         return 0;
 941 }
 942
 943 static int monitor_device_close(struct inode *inode, struct file *file)
 944 {
 945         if (atomic_dec_and_test(&dlm_monitor_opened))
 946                 dlm_stop_lockspaces();
 947         return 0;
 948 }
 949
 950 static const struct file_operations device_fops = {
 951         .open    = device_open,
 952         .release = device_close,
 953         .read    = device_read,
 954         .write   = device_write,
 955         .poll    = device_poll,
 956         .owner   = THIS_MODULE,
 957         .llseek  = noop_llseek,
 958 };
 959
 960 static const struct file_operations ctl_device_fops = {
 961         .open    = ctl_device_open,
 962         .release = ctl_device_close,
 963         .read    = device_read,
 964         .write   = device_write,
 965         .owner   = THIS_MODULE,
 966         .llseek  = noop_llseek,
 967 };
 968
 969 static struct miscdevice ctl_device = {
 970         .name  = "dlm-control",
 971         .fops  = &ctl_device_fops,
 972         .minor = MISC_DYNAMIC_MINOR,
 973 };
 974
 975 static const struct file_operations monitor_device_fops = {
 976         .open    = monitor_device_open,
 977         .release = monitor_device_close,
 978         .owner   = THIS_MODULE,
 979         .llseek  = noop_llseek,
 980 };
 981
 982 static struct miscdevice monitor_device = {
 983         .name  = "dlm-monitor",
 984         .fops  = &monitor_device_fops,
 985         .minor = MISC_DYNAMIC_MINOR,
 986 };
 987
 988 int __init dlm_user_init(void)
 989 {
 990         int error;
 991
 992         atomic_set(&dlm_monitor_opened, 0);
 993
 994         error = misc_register(&ctl_device);
 995         if (error) {
 996                 log_print("misc_register failed for control device");
 997                 goto out;
 998         }
 999
1000         error = misc_register(&monitor_device);
1001         if (error) {
1002                 log_print("misc_register failed for monitor device");
1003                 misc_deregister(&ctl_device);
1004         }
1005  out:
1006         return error;
1007 }
1008
1009 void dlm_user_exit(void)
1010 {
1011         misc_deregister(&ctl_device);
1012         misc_deregister(&monitor_device);
1013 }
1014