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