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