fs/dlm/user.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2006-2010 Red Hat, Inc.  All rights reserved.
   4  */
   5
   6 #include <linux/miscdevice.h>
   7 #include <linux/init.h>
   8 #include <linux/wait.h>
   9 #include <linux/file.h>
  10 #include <linux/fs.h>
  11 #include <linux/poll.h>
  12 #include <linux/signal.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/dlm.h>
  15 #include <linux/dlm_device.h>
  16 #include <linux/slab.h>
  17 #include <linux/sched/signal.h>
  18
  19 #include <trace/events/dlm.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 #include "ast.h"
  27 #include "config.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[];
  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 = (__user void *)(long)kb32->i.lock.castparam;
 114                 kb->i.lock.castaddr = (__user void *)(long)kb32->i.lock.castaddr;
 115                 kb->i.lock.bastparam = (__user void *)(long)kb32->i.lock.bastparam;
 116                 kb->i.lock.bastaddr = (__user void *)(long)kb32->i.lock.bastaddr;
 117                 kb->i.lock.lksb = (__user 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)(__force long)res->user_astaddr;
 133         res32->user_astparam = (__u32)(__force long)res->user_astparam;
 134         res32->user_lksb = (__u32)(__force 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         spin_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         spin_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 #ifdef CONFIG_DLM_DEPRECATED_API
 256         if (params->timeout)
 257                 pr_warn_once("========================================================\n"
 258                              "WARNING: the lkb timeout feature is being deprecated and\n"
 259                              "         will be removed in v6.2!\n"
 260                              "========================================================\n");
 261 #endif
 262
 263         ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
 264         if (!ua)
 265                 goto out;
 266         ua->proc = proc;
 267         ua->user_lksb = params->lksb;
 268         ua->castparam = params->castparam;
 269         ua->castaddr = params->castaddr;
 270         ua->bastparam = params->bastparam;
 271         ua->bastaddr = params->bastaddr;
 272         ua->xid = params->xid;
 273
 274         if (params->flags & DLM_LKF_CONVERT) {
 275 #ifdef CONFIG_DLM_DEPRECATED_API
 276                 error = dlm_user_convert(ls, ua,
 277                                          params->mode, params->flags,
 278                                          params->lkid, params->lvb,
 279                                          (unsigned long) params->timeout);
 280 #else
 281                 error = dlm_user_convert(ls, ua,
 282                                          params->mode, params->flags,
 283                                          params->lkid, params->lvb);
 284 #endif
 285         } else if (params->flags & DLM_LKF_ORPHAN) {
 286                 error = dlm_user_adopt_orphan(ls, ua,
 287                                          params->mode, params->flags,
 288                                          params->name, params->namelen,
 289                                          &lkid);
 290                 if (!error)
 291                         error = lkid;
 292         } else {
 293 #ifdef CONFIG_DLM_DEPRECATED_API
 294                 error = dlm_user_request(ls, ua,
 295                                          params->mode, params->flags,
 296                                          params->name, params->namelen,
 297                                          (unsigned long) params->timeout);
 298 #else
 299                 error = dlm_user_request(ls, ua,
 300                                          params->mode, params->flags,
 301                                          params->name, params->namelen);
 302 #endif
 303                 if (!error)
 304                         error = ua->lksb.sb_lkid;
 305         }
 306  out:
 307         dlm_put_lockspace(ls);
 308         return error;
 309 }
 310
 311 static int device_user_unlock(struct dlm_user_proc *proc,
 312                               struct dlm_lock_params *params)
 313 {
 314         struct dlm_ls *ls;
 315         struct dlm_user_args *ua;
 316         int error = -ENOMEM;
 317
 318         ls = dlm_find_lockspace_local(proc->lockspace);
 319         if (!ls)
 320                 return -ENOENT;
 321
 322         ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
 323         if (!ua)
 324                 goto out;
 325         ua->proc = proc;
 326         ua->user_lksb = params->lksb;
 327         ua->castparam = params->castparam;
 328         ua->castaddr = params->castaddr;
 329
 330         if (params->flags & DLM_LKF_CANCEL)
 331                 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
 332         else
 333                 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
 334                                         params->lvb);
 335  out:
 336         dlm_put_lockspace(ls);
 337         return error;
 338 }
 339
 340 static int device_user_deadlock(struct dlm_user_proc *proc,
 341                                 struct dlm_lock_params *params)
 342 {
 343         struct dlm_ls *ls;
 344         int error;
 345
 346         ls = dlm_find_lockspace_local(proc->lockspace);
 347         if (!ls)
 348                 return -ENOENT;
 349
 350         error = dlm_user_deadlock(ls, params->flags, params->lkid);
 351
 352         dlm_put_lockspace(ls);
 353         return error;
 354 }
 355
 356 static int dlm_device_register(struct dlm_ls *ls, char *name)
 357 {
 358         int error, len;
 359
 360         /* The device is already registered.  This happens when the
 361            lockspace is created multiple times from userspace. */
 362         if (ls->ls_device.name)
 363                 return 0;
 364
 365         error = -ENOMEM;
 366         len = strlen(name) + strlen(name_prefix) + 2;
 367         ls->ls_device.name = kzalloc(len, GFP_NOFS);
 368         if (!ls->ls_device.name)
 369                 goto fail;
 370
 371         snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
 372                  name);
 373         ls->ls_device.fops = &device_fops;
 374         ls->ls_device.minor = MISC_DYNAMIC_MINOR;
 375
 376         error = misc_register(&ls->ls_device);
 377         if (error) {
 378                 kfree(ls->ls_device.name);
 379                 /* this has to be set to NULL
 380                  * to avoid a double-free in dlm_device_deregister
 381                  */
 382                 ls->ls_device.name = NULL;
 383         }
 384 fail:
 385         return error;
 386 }
 387
 388 int dlm_device_deregister(struct dlm_ls *ls)
 389 {
 390         /* The device is not registered.  This happens when the lockspace
 391            was never used from userspace, or when device_create_lockspace()
 392            calls dlm_release_lockspace() after the register fails. */
 393         if (!ls->ls_device.name)
 394                 return 0;
 395
 396         misc_deregister(&ls->ls_device);
 397         kfree(ls->ls_device.name);
 398         return 0;
 399 }
 400
 401 static int device_user_purge(struct dlm_user_proc *proc,
 402                              struct dlm_purge_params *params)
 403 {
 404         struct dlm_ls *ls;
 405         int error;
 406
 407         ls = dlm_find_lockspace_local(proc->lockspace);
 408         if (!ls)
 409                 return -ENOENT;
 410
 411         error = dlm_user_purge(ls, proc, params->nodeid, params->pid);
 412
 413         dlm_put_lockspace(ls);
 414         return error;
 415 }
 416
 417 static int device_create_lockspace(struct dlm_lspace_params *params)
 418 {
 419         dlm_lockspace_t *lockspace;
 420         struct dlm_ls *ls;
 421         int error;
 422
 423         if (!capable(CAP_SYS_ADMIN))
 424                 return -EPERM;
 425
 426         error = dlm_new_user_lockspace(params->name, dlm_config.ci_cluster_name,
 427                                        params->flags, DLM_USER_LVB_LEN, NULL,
 428                                        NULL, NULL, &lockspace);
 429         if (error)
 430                 return error;
 431
 432         ls = dlm_find_lockspace_local(lockspace);
 433         if (!ls)
 434                 return -ENOENT;
 435
 436         error = dlm_device_register(ls, params->name);
 437         dlm_put_lockspace(ls);
 438
 439         if (error)
 440                 dlm_release_lockspace(lockspace, 0);
 441         else
 442                 error = ls->ls_device.minor;
 443
 444         return error;
 445 }
 446
 447 static int device_remove_lockspace(struct dlm_lspace_params *params)
 448 {
 449         dlm_lockspace_t *lockspace;
 450         struct dlm_ls *ls;
 451         int error, force = 0;
 452
 453         if (!capable(CAP_SYS_ADMIN))
 454                 return -EPERM;
 455
 456         ls = dlm_find_lockspace_device(params->minor);
 457         if (!ls)
 458                 return -ENOENT;
 459
 460         if (params->flags & DLM_USER_LSFLG_FORCEFREE)
 461                 force = 2;
 462
 463         lockspace = ls->ls_local_handle;
 464         dlm_put_lockspace(ls);
 465
 466         /* The final dlm_release_lockspace waits for references to go to
 467            zero, so all processes will need to close their device for the
 468            ls before the release will proceed.  release also calls the
 469            device_deregister above.  Converting a positive return value
 470            from release to zero means that userspace won't know when its
 471            release was the final one, but it shouldn't need to know. */
 472
 473         error = dlm_release_lockspace(lockspace, force);
 474         if (error > 0)
 475                 error = 0;
 476         return error;
 477 }
 478
 479 /* Check the user's version matches ours */
 480 static int check_version(struct dlm_write_request *req)
 481 {
 482         if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
 483             (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
 484              req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
 485
 486                 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
 487                        "user (%d.%d.%d) kernel (%d.%d.%d)\n",
 488                        current->comm,
 489                        task_pid_nr(current),
 490                        req->version[0],
 491                        req->version[1],
 492                        req->version[2],
 493                        DLM_DEVICE_VERSION_MAJOR,
 494                        DLM_DEVICE_VERSION_MINOR,
 495                        DLM_DEVICE_VERSION_PATCH);
 496                 return -EINVAL;
 497         }
 498         return 0;
 499 }
 500
 501 /*
 502  * device_write
 503  *
 504  *   device_user_lock
 505  *     dlm_user_request -> request_lock
 506  *     dlm_user_convert -> convert_lock
 507  *
 508  *   device_user_unlock
 509  *     dlm_user_unlock -> unlock_lock
 510  *     dlm_user_cancel -> cancel_lock
 511  *
 512  *   device_create_lockspace
 513  *     dlm_new_lockspace
 514  *
 515  *   device_remove_lockspace
 516  *     dlm_release_lockspace
 517  */
 518
 519 /* a write to a lockspace device is a lock or unlock request, a write
 520    to the control device is to create/remove a lockspace */
 521
 522 static ssize_t device_write(struct file *file, const char __user *buf,
 523                             size_t count, loff_t *ppos)
 524 {
 525         struct dlm_user_proc *proc = file->private_data;
 526         struct dlm_write_request *kbuf;
 527         int error;
 528
 529 #ifdef CONFIG_COMPAT
 530         if (count < sizeof(struct dlm_write_request32))
 531 #else
 532         if (count < sizeof(struct dlm_write_request))
 533 #endif
 534                 return -EINVAL;
 535
 536         /*
 537          * can't compare against COMPAT/dlm_write_request32 because
 538          * we don't yet know if is64bit is zero
 539          */
 540         if (count > sizeof(struct dlm_write_request) + DLM_RESNAME_MAXLEN)
 541                 return -EINVAL;
 542
 543         kbuf = memdup_user_nul(buf, count);
 544         if (IS_ERR(kbuf))
 545                 return PTR_ERR(kbuf);
 546
 547         if (check_version(kbuf)) {
 548                 error = -EBADE;
 549                 goto out_free;
 550         }
 551
 552 #ifdef CONFIG_COMPAT
 553         if (!kbuf->is64bit) {
 554                 struct dlm_write_request32 *k32buf;
 555                 int namelen = 0;
 556
 557                 if (count > sizeof(struct dlm_write_request32))
 558                         namelen = count - sizeof(struct dlm_write_request32);
 559
 560                 k32buf = (struct dlm_write_request32 *)kbuf;
 561
 562                 /* add 1 after namelen so that the name string is terminated */
 563                 kbuf = kzalloc(sizeof(struct dlm_write_request) + namelen + 1,
 564                                GFP_NOFS);
 565                 if (!kbuf) {
 566                         kfree(k32buf);
 567                         return -ENOMEM;
 568                 }
 569
 570                 if (proc)
 571                         set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
 572
 573                 compat_input(kbuf, k32buf, namelen);
 574                 kfree(k32buf);
 575         }
 576 #endif
 577
 578         /* do we really need this? can a write happen after a close? */
 579         if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
 580             (proc && test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))) {
 581                 error = -EINVAL;
 582                 goto out_free;
 583         }
 584
 585         error = -EINVAL;
 586
 587         switch (kbuf->cmd)
 588         {
 589         case DLM_USER_LOCK:
 590                 if (!proc) {
 591                         log_print("no locking on control device");
 592                         goto out_free;
 593                 }
 594                 error = device_user_lock(proc, &kbuf->i.lock);
 595                 break;
 596
 597         case DLM_USER_UNLOCK:
 598                 if (!proc) {
 599                         log_print("no locking on control device");
 600                         goto out_free;
 601                 }
 602                 error = device_user_unlock(proc, &kbuf->i.lock);
 603                 break;
 604
 605         case DLM_USER_DEADLOCK:
 606                 if (!proc) {
 607                         log_print("no locking on control device");
 608                         goto out_free;
 609                 }
 610                 error = device_user_deadlock(proc, &kbuf->i.lock);
 611                 break;
 612
 613         case DLM_USER_CREATE_LOCKSPACE:
 614                 if (proc) {
 615                         log_print("create/remove only on control device");
 616                         goto out_free;
 617                 }
 618                 error = device_create_lockspace(&kbuf->i.lspace);
 619                 break;
 620
 621         case DLM_USER_REMOVE_LOCKSPACE:
 622                 if (proc) {
 623                         log_print("create/remove only on control device");
 624                         goto out_free;
 625                 }
 626                 error = device_remove_lockspace(&kbuf->i.lspace);
 627                 break;
 628
 629         case DLM_USER_PURGE:
 630                 if (!proc) {
 631                         log_print("no locking on control device");
 632                         goto out_free;
 633                 }
 634                 error = device_user_purge(proc, &kbuf->i.purge);
 635                 break;
 636
 637         default:
 638                 log_print("Unknown command passed to DLM device : %d\n",
 639                           kbuf->cmd);
 640         }
 641
 642  out_free:
 643         kfree(kbuf);
 644         return error;
 645 }
 646
 647 /* Every process that opens the lockspace device has its own "proc" structure
 648    hanging off the open file that's used to keep track of locks owned by the
 649    process and asts that need to be delivered to the process. */
 650
 651 static int device_open(struct inode *inode, struct file *file)
 652 {
 653         struct dlm_user_proc *proc;
 654         struct dlm_ls *ls;
 655
 656         ls = dlm_find_lockspace_device(iminor(inode));
 657         if (!ls)
 658                 return -ENOENT;
 659
 660         proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS);
 661         if (!proc) {
 662                 dlm_put_lockspace(ls);
 663                 return -ENOMEM;
 664         }
 665
 666         proc->lockspace = ls->ls_local_handle;
 667         INIT_LIST_HEAD(&proc->asts);
 668         INIT_LIST_HEAD(&proc->locks);
 669         INIT_LIST_HEAD(&proc->unlocking);
 670         spin_lock_init(&proc->asts_spin);
 671         spin_lock_init(&proc->locks_spin);
 672         init_waitqueue_head(&proc->wait);
 673         file->private_data = proc;
 674
 675         return 0;
 676 }
 677
 678 static int device_close(struct inode *inode, struct file *file)
 679 {
 680         struct dlm_user_proc *proc = file->private_data;
 681         struct dlm_ls *ls;
 682
 683         ls = dlm_find_lockspace_local(proc->lockspace);
 684         if (!ls)
 685                 return -ENOENT;
 686
 687         set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
 688
 689         dlm_clear_proc_locks(ls, proc);
 690
 691         /* at this point no more lkb's should exist for this lockspace,
 692            so there's no chance of dlm_user_add_ast() being called and
 693            looking for lkb->ua->proc */
 694
 695         kfree(proc);
 696         file->private_data = NULL;
 697
 698         dlm_put_lockspace(ls);
 699         dlm_put_lockspace(ls);  /* for the find in device_open() */
 700
 701         /* FIXME: AUTOFREE: if this ls is no longer used do
 702            device_remove_lockspace() */
 703
 704         return 0;
 705 }
 706
 707 static int copy_result_to_user(struct dlm_user_args *ua, int compat,
 708                                uint32_t flags, int mode, int copy_lvb,
 709                                char __user *buf, size_t count)
 710 {
 711 #ifdef CONFIG_COMPAT
 712         struct dlm_lock_result32 result32;
 713 #endif
 714         struct dlm_lock_result result;
 715         void *resultptr;
 716         int error=0;
 717         int len;
 718         int struct_len;
 719
 720         memset(&result, 0, sizeof(struct dlm_lock_result));
 721         result.version[0] = DLM_DEVICE_VERSION_MAJOR;
 722         result.version[1] = DLM_DEVICE_VERSION_MINOR;
 723         result.version[2] = DLM_DEVICE_VERSION_PATCH;
 724         memcpy(&result.lksb, &ua->lksb, offsetof(struct dlm_lksb, sb_lvbptr));
 725         result.user_lksb = ua->user_lksb;
 726
 727         /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
 728            in a conversion unless the conversion is successful.  See code
 729            in dlm_user_convert() for updating ua from ua_tmp.  OpenVMS, though,
 730            notes that a new blocking AST address and parameter are set even if
 731            the conversion fails, so maybe we should just do that. */
 732
 733         if (flags & DLM_CB_BAST) {
 734                 result.user_astaddr = ua->bastaddr;
 735                 result.user_astparam = ua->bastparam;
 736                 result.bast_mode = mode;
 737         } else {
 738                 result.user_astaddr = ua->castaddr;
 739                 result.user_astparam = ua->castparam;
 740         }
 741
 742 #ifdef CONFIG_COMPAT
 743         if (compat)
 744                 len = sizeof(struct dlm_lock_result32);
 745         else
 746 #endif
 747                 len = sizeof(struct dlm_lock_result);
 748         struct_len = len;
 749
 750         /* copy lvb to userspace if there is one, it's been updated, and
 751            the user buffer has space for it */
 752
 753         if (copy_lvb && ua->lksb.sb_lvbptr && count >= len + DLM_USER_LVB_LEN) {
 754                 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
 755                                  DLM_USER_LVB_LEN)) {
 756                         error = -EFAULT;
 757                         goto out;
 758                 }
 759
 760                 result.lvb_offset = len;
 761                 len += DLM_USER_LVB_LEN;
 762         }
 763
 764         result.length = len;
 765         resultptr = &result;
 766 #ifdef CONFIG_COMPAT
 767         if (compat) {
 768                 compat_output(&result, &result32);
 769                 resultptr = &result32;
 770         }
 771 #endif
 772
 773         if (copy_to_user(buf, resultptr, struct_len))
 774                 error = -EFAULT;
 775         else
 776                 error = len;
 777  out:
 778         return error;
 779 }
 780
 781 static int copy_version_to_user(char __user *buf, size_t count)
 782 {
 783         struct dlm_device_version ver;
 784
 785         memset(&ver, 0, sizeof(struct dlm_device_version));
 786         ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
 787         ver.version[1] = DLM_DEVICE_VERSION_MINOR;
 788         ver.version[2] = DLM_DEVICE_VERSION_PATCH;
 789
 790         if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
 791                 return -EFAULT;
 792         return sizeof(struct dlm_device_version);
 793 }
 794
 795 /* a read returns a single ast described in a struct dlm_lock_result */
 796
 797 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
 798                            loff_t *ppos)
 799 {
 800         struct dlm_user_proc *proc = file->private_data;
 801         struct dlm_lkb *lkb;
 802         DECLARE_WAITQUEUE(wait, current);
 803         struct dlm_callback cb;
 804         int rv, resid, copy_lvb = 0;
 805         int old_mode, new_mode;
 806
 807         if (count == sizeof(struct dlm_device_version)) {
 808                 rv = copy_version_to_user(buf, count);
 809                 return rv;
 810         }
 811
 812         if (!proc) {
 813                 log_print("non-version read from control device %zu", count);
 814                 return -EINVAL;
 815         }
 816
 817 #ifdef CONFIG_COMPAT
 818         if (count < sizeof(struct dlm_lock_result32))
 819 #else
 820         if (count < sizeof(struct dlm_lock_result))
 821 #endif
 822                 return -EINVAL;
 823
 824  try_another:
 825
 826         /* do we really need this? can a read happen after a close? */
 827         if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
 828                 return -EINVAL;
 829
 830         spin_lock(&proc->asts_spin);
 831         if (list_empty(&proc->asts)) {
 832                 if (file->f_flags & O_NONBLOCK) {
 833                         spin_unlock(&proc->asts_spin);
 834                         return -EAGAIN;
 835                 }
 836
 837                 add_wait_queue(&proc->wait, &wait);
 838
 839         repeat:
 840                 set_current_state(TASK_INTERRUPTIBLE);
 841                 if (list_empty(&proc->asts) && !signal_pending(current)) {
 842                         spin_unlock(&proc->asts_spin);
 843                         schedule();
 844                         spin_lock(&proc->asts_spin);
 845                         goto repeat;
 846                 }
 847                 set_current_state(TASK_RUNNING);
 848                 remove_wait_queue(&proc->wait, &wait);
 849
 850                 if (signal_pending(current)) {
 851                         spin_unlock(&proc->asts_spin);
 852                         return -ERESTARTSYS;
 853                 }
 854         }
 855
 856         /* if we empty lkb_callbacks, we don't want to unlock the spinlock
 857            without removing lkb_cb_list; so empty lkb_cb_list is always
 858            consistent with empty lkb_callbacks */
 859
 860         lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_cb_list);
 861
 862         /* rem_lkb_callback sets a new lkb_last_cast */
 863         old_mode = lkb->lkb_last_cast.mode;
 864
 865         rv = dlm_rem_lkb_callback(lkb->lkb_resource->res_ls, lkb, &cb, &resid);
 866         if (rv < 0) {
 867                 /* this shouldn't happen; lkb should have been removed from
 868                    list when resid was zero */
 869                 log_print("dlm_rem_lkb_callback empty %x", lkb->lkb_id);
 870                 list_del_init(&lkb->lkb_cb_list);
 871                 spin_unlock(&proc->asts_spin);
 872                 /* removes ref for proc->asts, may cause lkb to be freed */
 873                 dlm_put_lkb(lkb);
 874                 goto try_another;
 875         }
 876         if (!resid)
 877                 list_del_init(&lkb->lkb_cb_list);
 878         spin_unlock(&proc->asts_spin);
 879
 880         if (cb.flags & DLM_CB_SKIP) {
 881                 /* removes ref for proc->asts, may cause lkb to be freed */
 882                 if (!resid)
 883                         dlm_put_lkb(lkb);
 884                 goto try_another;
 885         }
 886
 887         if (cb.flags & DLM_CB_BAST) {
 888                 trace_dlm_bast(lkb->lkb_resource->res_ls, lkb, cb.mode);
 889         } else if (cb.flags & DLM_CB_CAST) {
 890                 new_mode = cb.mode;
 891
 892                 if (!cb.sb_status && lkb->lkb_lksb->sb_lvbptr &&
 893                     dlm_lvb_operations[old_mode + 1][new_mode + 1])
 894                         copy_lvb = 1;
 895
 896                 lkb->lkb_lksb->sb_status = cb.sb_status;
 897                 lkb->lkb_lksb->sb_flags = cb.sb_flags;
 898                 trace_dlm_ast(lkb->lkb_resource->res_ls, lkb);
 899         }
 900
 901         rv = copy_result_to_user(lkb->lkb_ua,
 902                                  test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
 903                                  cb.flags, cb.mode, copy_lvb, buf, count);
 904
 905         /* removes ref for proc->asts, may cause lkb to be freed */
 906         if (!resid)
 907                 dlm_put_lkb(lkb);
 908
 909         return rv;
 910 }
 911
 912 static __poll_t device_poll(struct file *file, poll_table *wait)
 913 {
 914         struct dlm_user_proc *proc = file->private_data;
 915
 916         poll_wait(file, &proc->wait, wait);
 917
 918         spin_lock(&proc->asts_spin);
 919         if (!list_empty(&proc->asts)) {
 920                 spin_unlock(&proc->asts_spin);
 921                 return EPOLLIN | EPOLLRDNORM;
 922         }
 923         spin_unlock(&proc->asts_spin);
 924         return 0;
 925 }
 926
 927 int dlm_user_daemon_available(void)
 928 {
 929         /* dlm_controld hasn't started (or, has started, but not
 930            properly populated configfs) */
 931
 932         if (!dlm_our_nodeid())
 933                 return 0;
 934
 935         /* This is to deal with versions of dlm_controld that don't
 936            know about the monitor device.  We assume that if the
 937            dlm_controld was started (above), but the monitor device
 938            was never opened, that it's an old version.  dlm_controld
 939            should open the monitor device before populating configfs. */
 940
 941         if (dlm_monitor_unused)
 942                 return 1;
 943
 944         return atomic_read(&dlm_monitor_opened) ? 1 : 0;
 945 }
 946
 947 static int ctl_device_open(struct inode *inode, struct file *file)
 948 {
 949         file->private_data = NULL;
 950         return 0;
 951 }
 952
 953 static int ctl_device_close(struct inode *inode, struct file *file)
 954 {
 955         return 0;
 956 }
 957
 958 static int monitor_device_open(struct inode *inode, struct file *file)
 959 {
 960         atomic_inc(&dlm_monitor_opened);
 961         dlm_monitor_unused = 0;
 962         return 0;
 963 }
 964
 965 static int monitor_device_close(struct inode *inode, struct file *file)
 966 {
 967         if (atomic_dec_and_test(&dlm_monitor_opened))
 968                 dlm_stop_lockspaces();
 969         return 0;
 970 }
 971
 972 static const struct file_operations device_fops = {
 973         .open    = device_open,
 974         .release = device_close,
 975         .read    = device_read,
 976         .write   = device_write,
 977         .poll    = device_poll,
 978         .owner   = THIS_MODULE,
 979         .llseek  = noop_llseek,
 980 };
 981
 982 static const struct file_operations ctl_device_fops = {
 983         .open    = ctl_device_open,
 984         .release = ctl_device_close,
 985         .read    = device_read,
 986         .write   = device_write,
 987         .owner   = THIS_MODULE,
 988         .llseek  = noop_llseek,
 989 };
 990
 991 static struct miscdevice ctl_device = {
 992         .name  = "dlm-control",
 993         .fops  = &ctl_device_fops,
 994         .minor = MISC_DYNAMIC_MINOR,
 995 };
 996
 997 static const struct file_operations monitor_device_fops = {
 998         .open    = monitor_device_open,
 999         .release = monitor_device_close,
1000         .owner   = THIS_MODULE,
1001         .llseek  = noop_llseek,
1002 };
1003
1004 static struct miscdevice monitor_device = {
1005         .name  = "dlm-monitor",
1006         .fops  = &monitor_device_fops,
1007         .minor = MISC_DYNAMIC_MINOR,
1008 };
1009
1010 int __init dlm_user_init(void)
1011 {
1012         int error;
1013
1014         atomic_set(&dlm_monitor_opened, 0);
1015
1016         error = misc_register(&ctl_device);
1017         if (error) {
1018                 log_print("misc_register failed for control device");
1019                 goto out;
1020         }
1021
1022         error = misc_register(&monitor_device);
1023         if (error) {
1024                 log_print("misc_register failed for monitor device");
1025                 misc_deregister(&ctl_device);
1026         }
1027  out:
1028         return error;
1029 }
1030
1031 void dlm_user_exit(void)
1032 {
1033         misc_deregister(&ctl_device);
1034         misc_deregister(&monitor_device);
1035 }
1036