1 /* 2 * Copyright (C) 2006-2010 Red Hat, Inc. All rights reserved. 3 * 4 * This copyrighted material is made available to anyone wishing to use, 5 * modify, copy, or redistribute it subject to the terms and conditions 6 * of the GNU General Public License v.2. 7 */ 8 9 #include <linux/miscdevice.h> 10 #include <linux/init.h> 11 #include <linux/wait.h> 12 #include <linux/module.h> 13 #include <linux/file.h> 14 #include <linux/fs.h> 15 #include <linux/poll.h> 16 #include <linux/signal.h> 17 #include <linux/spinlock.h> 18 #include <linux/dlm.h> 19 #include <linux/dlm_device.h> 20 21 #include "dlm_internal.h" 22 #include "lockspace.h" 23 #include "lock.h" 24 #include "lvb_table.h" 25 #include "user.h" 26 27 static const char name_prefix[] = "dlm"; 28 static 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[0]; 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 = (void *)(long)kb32->i.lock.castparam; 112 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr; 113 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam; 114 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr; 115 kb->i.lock.lksb = (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 res32->version[0] = res->version[0]; 125 res32->version[1] = res->version[1]; 126 res32->version[2] = res->version[2]; 127 128 res32->user_astaddr = (__u32)(long)res->user_astaddr; 129 res32->user_astparam = (__u32)(long)res->user_astparam; 130 res32->user_lksb = (__u32)(long)res->user_lksb; 131 res32->bast_mode = res->bast_mode; 132 133 res32->lvb_offset = res->lvb_offset; 134 res32->length = res->length; 135 136 res32->lksb.sb_status = res->lksb.sb_status; 137 res32->lksb.sb_flags = res->lksb.sb_flags; 138 res32->lksb.sb_lkid = res->lksb.sb_lkid; 139 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr; 140 } 141 #endif 142 143 /* Figure out if this lock is at the end of its life and no longer 144 available for the application to use. The lkb still exists until 145 the final ast is read. A lock becomes EOL in three situations: 146 1. a noqueue request fails with EAGAIN 147 2. an unlock completes with EUNLOCK 148 3. a cancel of a waiting request completes with ECANCEL/EDEADLK 149 An EOL lock needs to be removed from the process's list of locks. 150 And we can't allow any new operation on an EOL lock. This is 151 not related to the lifetime of the lkb struct which is managed 152 entirely by refcount. */ 153 154 static int lkb_is_endoflife(struct dlm_lkb *lkb, int sb_status, int type) 155 { 156 switch (sb_status) { 157 case -DLM_EUNLOCK: 158 return 1; 159 case -DLM_ECANCEL: 160 case -ETIMEDOUT: 161 case -EDEADLK: 162 if (lkb->lkb_grmode == DLM_LOCK_IV) 163 return 1; 164 break; 165 case -EAGAIN: 166 if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV) 167 return 1; 168 break; 169 } 170 return 0; 171 } 172 173 /* we could possibly check if the cancel of an orphan has resulted in the lkb 174 being removed and then remove that lkb from the orphans list and free it */ 175 176 void dlm_user_add_ast(struct dlm_lkb *lkb, int type, int mode) 177 { 178 struct dlm_ls *ls; 179 struct dlm_user_args *ua; 180 struct dlm_user_proc *proc; 181 int eol = 0, ast_type; 182 183 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) 184 return; 185 186 ls = lkb->lkb_resource->res_ls; 187 mutex_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 (type == AST_BAST && ua->bastaddr == NULL) 203 goto out; 204 205 spin_lock(&proc->asts_spin); 206 207 ast_type = lkb->lkb_ast_type; 208 lkb->lkb_ast_type |= type; 209 if (type == AST_BAST) 210 lkb->lkb_bastmode = mode; 211 else 212 lkb->lkb_castmode = mode; 213 214 if (!ast_type) { 215 kref_get(&lkb->lkb_ref); 216 list_add_tail(&lkb->lkb_astqueue, &proc->asts); 217 wake_up_interruptible(&proc->wait); 218 } 219 if (type == AST_COMP && (ast_type & AST_COMP)) 220 log_debug(ls, "ast overlap %x status %x %x", 221 lkb->lkb_id, ua->lksb.sb_status, lkb->lkb_flags); 222 223 eol = lkb_is_endoflife(lkb, ua->lksb.sb_status, type); 224 if (eol) { 225 lkb->lkb_ast_type &= ~AST_BAST; 226 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE; 227 } 228 229 /* We want to copy the lvb to userspace when the completion 230 ast is read if the status is 0, the lock has an lvb and 231 lvb_ops says we should. We could probably have set_lvb_lock() 232 set update_user_lvb instead and not need old_mode */ 233 234 if ((lkb->lkb_ast_type & AST_COMP) && 235 (lkb->lkb_lksb->sb_status == 0) && 236 lkb->lkb_lksb->sb_lvbptr && 237 dlm_lvb_operations[ua->old_mode + 1][lkb->lkb_grmode + 1]) 238 ua->update_user_lvb = 1; 239 else 240 ua->update_user_lvb = 0; 241 242 spin_unlock(&proc->asts_spin); 243 244 if (eol) { 245 spin_lock(&proc->locks_spin); 246 if (!list_empty(&lkb->lkb_ownqueue)) { 247 list_del_init(&lkb->lkb_ownqueue); 248 dlm_put_lkb(lkb); 249 } 250 spin_unlock(&proc->locks_spin); 251 } 252 out: 253 mutex_unlock(&ls->ls_clear_proc_locks); 254 } 255 256 static int device_user_lock(struct dlm_user_proc *proc, 257 struct dlm_lock_params *params) 258 { 259 struct dlm_ls *ls; 260 struct dlm_user_args *ua; 261 int error = -ENOMEM; 262 263 ls = dlm_find_lockspace_local(proc->lockspace); 264 if (!ls) 265 return -ENOENT; 266 267 if (!params->castaddr || !params->lksb) { 268 error = -EINVAL; 269 goto out; 270 } 271 272 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS); 273 if (!ua) 274 goto out; 275 ua->proc = proc; 276 ua->user_lksb = params->lksb; 277 ua->castparam = params->castparam; 278 ua->castaddr = params->castaddr; 279 ua->bastparam = params->bastparam; 280 ua->bastaddr = params->bastaddr; 281 ua->xid = params->xid; 282 283 if (params->flags & DLM_LKF_CONVERT) 284 error = dlm_user_convert(ls, ua, 285 params->mode, params->flags, 286 params->lkid, params->lvb, 287 (unsigned long) params->timeout); 288 else { 289 error = dlm_user_request(ls, ua, 290 params->mode, params->flags, 291 params->name, params->namelen, 292 (unsigned long) params->timeout); 293 if (!error) 294 error = ua->lksb.sb_lkid; 295 } 296 out: 297 dlm_put_lockspace(ls); 298 return error; 299 } 300 301 static int device_user_unlock(struct dlm_user_proc *proc, 302 struct dlm_lock_params *params) 303 { 304 struct dlm_ls *ls; 305 struct dlm_user_args *ua; 306 int error = -ENOMEM; 307 308 ls = dlm_find_lockspace_local(proc->lockspace); 309 if (!ls) 310 return -ENOENT; 311 312 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS); 313 if (!ua) 314 goto out; 315 ua->proc = proc; 316 ua->user_lksb = params->lksb; 317 ua->castparam = params->castparam; 318 ua->castaddr = params->castaddr; 319 320 if (params->flags & DLM_LKF_CANCEL) 321 error = dlm_user_cancel(ls, ua, params->flags, params->lkid); 322 else 323 error = dlm_user_unlock(ls, ua, params->flags, params->lkid, 324 params->lvb); 325 out: 326 dlm_put_lockspace(ls); 327 return error; 328 } 329 330 static int device_user_deadlock(struct dlm_user_proc *proc, 331 struct dlm_lock_params *params) 332 { 333 struct dlm_ls *ls; 334 int error; 335 336 ls = dlm_find_lockspace_local(proc->lockspace); 337 if (!ls) 338 return -ENOENT; 339 340 error = dlm_user_deadlock(ls, params->flags, params->lkid); 341 342 dlm_put_lockspace(ls); 343 return error; 344 } 345 346 static int dlm_device_register(struct dlm_ls *ls, char *name) 347 { 348 int error, len; 349 350 /* The device is already registered. This happens when the 351 lockspace is created multiple times from userspace. */ 352 if (ls->ls_device.name) 353 return 0; 354 355 error = -ENOMEM; 356 len = strlen(name) + strlen(name_prefix) + 2; 357 ls->ls_device.name = kzalloc(len, GFP_NOFS); 358 if (!ls->ls_device.name) 359 goto fail; 360 361 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix, 362 name); 363 ls->ls_device.fops = &device_fops; 364 ls->ls_device.minor = MISC_DYNAMIC_MINOR; 365 366 error = misc_register(&ls->ls_device); 367 if (error) { 368 kfree(ls->ls_device.name); 369 } 370 fail: 371 return error; 372 } 373 374 int dlm_device_deregister(struct dlm_ls *ls) 375 { 376 int error; 377 378 /* The device is not registered. This happens when the lockspace 379 was never used from userspace, or when device_create_lockspace() 380 calls dlm_release_lockspace() after the register fails. */ 381 if (!ls->ls_device.name) 382 return 0; 383 384 error = misc_deregister(&ls->ls_device); 385 if (!error) 386 kfree(ls->ls_device.name); 387 return error; 388 } 389 390 static int device_user_purge(struct dlm_user_proc *proc, 391 struct dlm_purge_params *params) 392 { 393 struct dlm_ls *ls; 394 int error; 395 396 ls = dlm_find_lockspace_local(proc->lockspace); 397 if (!ls) 398 return -ENOENT; 399 400 error = dlm_user_purge(ls, proc, params->nodeid, params->pid); 401 402 dlm_put_lockspace(ls); 403 return error; 404 } 405 406 static int device_create_lockspace(struct dlm_lspace_params *params) 407 { 408 dlm_lockspace_t *lockspace; 409 struct dlm_ls *ls; 410 int error; 411 412 if (!capable(CAP_SYS_ADMIN)) 413 return -EPERM; 414 415 error = dlm_new_lockspace(params->name, strlen(params->name), 416 &lockspace, params->flags, DLM_USER_LVB_LEN); 417 if (error) 418 return error; 419 420 ls = dlm_find_lockspace_local(lockspace); 421 if (!ls) 422 return -ENOENT; 423 424 error = dlm_device_register(ls, params->name); 425 dlm_put_lockspace(ls); 426 427 if (error) 428 dlm_release_lockspace(lockspace, 0); 429 else 430 error = ls->ls_device.minor; 431 432 return error; 433 } 434 435 static int device_remove_lockspace(struct dlm_lspace_params *params) 436 { 437 dlm_lockspace_t *lockspace; 438 struct dlm_ls *ls; 439 int error, force = 0; 440 441 if (!capable(CAP_SYS_ADMIN)) 442 return -EPERM; 443 444 ls = dlm_find_lockspace_device(params->minor); 445 if (!ls) 446 return -ENOENT; 447 448 if (params->flags & DLM_USER_LSFLG_FORCEFREE) 449 force = 2; 450 451 lockspace = ls->ls_local_handle; 452 dlm_put_lockspace(ls); 453 454 /* The final dlm_release_lockspace waits for references to go to 455 zero, so all processes will need to close their device for the 456 ls before the release will proceed. release also calls the 457 device_deregister above. Converting a positive return value 458 from release to zero means that userspace won't know when its 459 release was the final one, but it shouldn't need to know. */ 460 461 error = dlm_release_lockspace(lockspace, force); 462 if (error > 0) 463 error = 0; 464 return error; 465 } 466 467 /* Check the user's version matches ours */ 468 static int check_version(struct dlm_write_request *req) 469 { 470 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR || 471 (req->version[0] == DLM_DEVICE_VERSION_MAJOR && 472 req->version[1] > DLM_DEVICE_VERSION_MINOR)) { 473 474 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch " 475 "user (%d.%d.%d) kernel (%d.%d.%d)\n", 476 current->comm, 477 task_pid_nr(current), 478 req->version[0], 479 req->version[1], 480 req->version[2], 481 DLM_DEVICE_VERSION_MAJOR, 482 DLM_DEVICE_VERSION_MINOR, 483 DLM_DEVICE_VERSION_PATCH); 484 return -EINVAL; 485 } 486 return 0; 487 } 488 489 /* 490 * device_write 491 * 492 * device_user_lock 493 * dlm_user_request -> request_lock 494 * dlm_user_convert -> convert_lock 495 * 496 * device_user_unlock 497 * dlm_user_unlock -> unlock_lock 498 * dlm_user_cancel -> cancel_lock 499 * 500 * device_create_lockspace 501 * dlm_new_lockspace 502 * 503 * device_remove_lockspace 504 * dlm_release_lockspace 505 */ 506 507 /* a write to a lockspace device is a lock or unlock request, a write 508 to the control device is to create/remove a lockspace */ 509 510 static ssize_t device_write(struct file *file, const char __user *buf, 511 size_t count, loff_t *ppos) 512 { 513 struct dlm_user_proc *proc = file->private_data; 514 struct dlm_write_request *kbuf; 515 sigset_t tmpsig, allsigs; 516 int error; 517 518 #ifdef CONFIG_COMPAT 519 if (count < sizeof(struct dlm_write_request32)) 520 #else 521 if (count < sizeof(struct dlm_write_request)) 522 #endif 523 return -EINVAL; 524 525 kbuf = kzalloc(count + 1, GFP_NOFS); 526 if (!kbuf) 527 return -ENOMEM; 528 529 if (copy_from_user(kbuf, buf, count)) { 530 error = -EFAULT; 531 goto out_free; 532 } 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 sigfillset(&allsigs); 573 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig); 574 575 error = -EINVAL; 576 577 switch (kbuf->cmd) 578 { 579 case DLM_USER_LOCK: 580 if (!proc) { 581 log_print("no locking on control device"); 582 goto out_sig; 583 } 584 error = device_user_lock(proc, &kbuf->i.lock); 585 break; 586 587 case DLM_USER_UNLOCK: 588 if (!proc) { 589 log_print("no locking on control device"); 590 goto out_sig; 591 } 592 error = device_user_unlock(proc, &kbuf->i.lock); 593 break; 594 595 case DLM_USER_DEADLOCK: 596 if (!proc) { 597 log_print("no locking on control device"); 598 goto out_sig; 599 } 600 error = device_user_deadlock(proc, &kbuf->i.lock); 601 break; 602 603 case DLM_USER_CREATE_LOCKSPACE: 604 if (proc) { 605 log_print("create/remove only on control device"); 606 goto out_sig; 607 } 608 error = device_create_lockspace(&kbuf->i.lspace); 609 break; 610 611 case DLM_USER_REMOVE_LOCKSPACE: 612 if (proc) { 613 log_print("create/remove only on control device"); 614 goto out_sig; 615 } 616 error = device_remove_lockspace(&kbuf->i.lspace); 617 break; 618 619 case DLM_USER_PURGE: 620 if (!proc) { 621 log_print("no locking on control device"); 622 goto out_sig; 623 } 624 error = device_user_purge(proc, &kbuf->i.purge); 625 break; 626 627 default: 628 log_print("Unknown command passed to DLM device : %d\n", 629 kbuf->cmd); 630 } 631 632 out_sig: 633 sigprocmask(SIG_SETMASK, &tmpsig, NULL); 634 recalc_sigpending(); 635 out_free: 636 kfree(kbuf); 637 return error; 638 } 639 640 /* Every process that opens the lockspace device has its own "proc" structure 641 hanging off the open file that's used to keep track of locks owned by the 642 process and asts that need to be delivered to the process. */ 643 644 static int device_open(struct inode *inode, struct file *file) 645 { 646 struct dlm_user_proc *proc; 647 struct dlm_ls *ls; 648 649 ls = dlm_find_lockspace_device(iminor(inode)); 650 if (!ls) 651 return -ENOENT; 652 653 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS); 654 if (!proc) { 655 dlm_put_lockspace(ls); 656 return -ENOMEM; 657 } 658 659 proc->lockspace = ls->ls_local_handle; 660 INIT_LIST_HEAD(&proc->asts); 661 INIT_LIST_HEAD(&proc->locks); 662 INIT_LIST_HEAD(&proc->unlocking); 663 spin_lock_init(&proc->asts_spin); 664 spin_lock_init(&proc->locks_spin); 665 init_waitqueue_head(&proc->wait); 666 file->private_data = proc; 667 668 return 0; 669 } 670 671 static int device_close(struct inode *inode, struct file *file) 672 { 673 struct dlm_user_proc *proc = file->private_data; 674 struct dlm_ls *ls; 675 sigset_t tmpsig, allsigs; 676 677 ls = dlm_find_lockspace_local(proc->lockspace); 678 if (!ls) 679 return -ENOENT; 680 681 sigfillset(&allsigs); 682 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig); 683 684 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags); 685 686 dlm_clear_proc_locks(ls, proc); 687 688 /* at this point no more lkb's should exist for this lockspace, 689 so there's no chance of dlm_user_add_ast() being called and 690 looking for lkb->ua->proc */ 691 692 kfree(proc); 693 file->private_data = NULL; 694 695 dlm_put_lockspace(ls); 696 dlm_put_lockspace(ls); /* for the find in device_open() */ 697 698 /* FIXME: AUTOFREE: if this ls is no longer used do 699 device_remove_lockspace() */ 700 701 sigprocmask(SIG_SETMASK, &tmpsig, NULL); 702 recalc_sigpending(); 703 704 return 0; 705 } 706 707 static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type, 708 int bmode, char __user *buf, size_t count) 709 { 710 #ifdef CONFIG_COMPAT 711 struct dlm_lock_result32 result32; 712 #endif 713 struct dlm_lock_result result; 714 void *resultptr; 715 int error=0; 716 int len; 717 int struct_len; 718 719 memset(&result, 0, sizeof(struct dlm_lock_result)); 720 result.version[0] = DLM_DEVICE_VERSION_MAJOR; 721 result.version[1] = DLM_DEVICE_VERSION_MINOR; 722 result.version[2] = DLM_DEVICE_VERSION_PATCH; 723 memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb)); 724 result.user_lksb = ua->user_lksb; 725 726 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated 727 in a conversion unless the conversion is successful. See code 728 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though, 729 notes that a new blocking AST address and parameter are set even if 730 the conversion fails, so maybe we should just do that. */ 731 732 if (type == AST_BAST) { 733 result.user_astaddr = ua->bastaddr; 734 result.user_astparam = ua->bastparam; 735 result.bast_mode = bmode; 736 } else { 737 result.user_astaddr = ua->castaddr; 738 result.user_astparam = ua->castparam; 739 } 740 741 #ifdef CONFIG_COMPAT 742 if (compat) 743 len = sizeof(struct dlm_lock_result32); 744 else 745 #endif 746 len = sizeof(struct dlm_lock_result); 747 struct_len = len; 748 749 /* copy lvb to userspace if there is one, it's been updated, and 750 the user buffer has space for it */ 751 752 if (ua->update_user_lvb && ua->lksb.sb_lvbptr && 753 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 int error, type=0, bmode=0, removed = 0; 804 805 if (count == sizeof(struct dlm_device_version)) { 806 error = copy_version_to_user(buf, count); 807 return error; 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 /* do we really need this? can a read happen after a close? */ 823 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags)) 824 return -EINVAL; 825 826 spin_lock(&proc->asts_spin); 827 if (list_empty(&proc->asts)) { 828 if (file->f_flags & O_NONBLOCK) { 829 spin_unlock(&proc->asts_spin); 830 return -EAGAIN; 831 } 832 833 add_wait_queue(&proc->wait, &wait); 834 835 repeat: 836 set_current_state(TASK_INTERRUPTIBLE); 837 if (list_empty(&proc->asts) && !signal_pending(current)) { 838 spin_unlock(&proc->asts_spin); 839 schedule(); 840 spin_lock(&proc->asts_spin); 841 goto repeat; 842 } 843 set_current_state(TASK_RUNNING); 844 remove_wait_queue(&proc->wait, &wait); 845 846 if (signal_pending(current)) { 847 spin_unlock(&proc->asts_spin); 848 return -ERESTARTSYS; 849 } 850 } 851 852 /* there may be both completion and blocking asts to return for 853 the lkb, don't remove lkb from asts list unless no asts remain */ 854 855 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_astqueue); 856 857 if (lkb->lkb_ast_type & AST_COMP) { 858 lkb->lkb_ast_type &= ~AST_COMP; 859 type = AST_COMP; 860 } else if (lkb->lkb_ast_type & AST_BAST) { 861 lkb->lkb_ast_type &= ~AST_BAST; 862 type = AST_BAST; 863 bmode = lkb->lkb_bastmode; 864 } 865 866 if (!lkb->lkb_ast_type) { 867 list_del(&lkb->lkb_astqueue); 868 removed = 1; 869 } 870 spin_unlock(&proc->asts_spin); 871 872 error = copy_result_to_user(lkb->lkb_ua, 873 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags), 874 type, bmode, buf, count); 875 876 /* removes reference for the proc->asts lists added by 877 dlm_user_add_ast() and may result in the lkb being freed */ 878 if (removed) 879 dlm_put_lkb(lkb); 880 881 return error; 882 } 883 884 static unsigned int device_poll(struct file *file, poll_table *wait) 885 { 886 struct dlm_user_proc *proc = file->private_data; 887 888 poll_wait(file, &proc->wait, wait); 889 890 spin_lock(&proc->asts_spin); 891 if (!list_empty(&proc->asts)) { 892 spin_unlock(&proc->asts_spin); 893 return POLLIN | POLLRDNORM; 894 } 895 spin_unlock(&proc->asts_spin); 896 return 0; 897 } 898 899 int dlm_user_daemon_available(void) 900 { 901 /* dlm_controld hasn't started (or, has started, but not 902 properly populated configfs) */ 903 904 if (!dlm_our_nodeid()) 905 return 0; 906 907 /* This is to deal with versions of dlm_controld that don't 908 know about the monitor device. We assume that if the 909 dlm_controld was started (above), but the monitor device 910 was never opened, that it's an old version. dlm_controld 911 should open the monitor device before populating configfs. */ 912 913 if (dlm_monitor_unused) 914 return 1; 915 916 return atomic_read(&dlm_monitor_opened) ? 1 : 0; 917 } 918 919 static int ctl_device_open(struct inode *inode, struct file *file) 920 { 921 file->private_data = NULL; 922 return 0; 923 } 924 925 static int ctl_device_close(struct inode *inode, struct file *file) 926 { 927 return 0; 928 } 929 930 static int monitor_device_open(struct inode *inode, struct file *file) 931 { 932 atomic_inc(&dlm_monitor_opened); 933 dlm_monitor_unused = 0; 934 return 0; 935 } 936 937 static int monitor_device_close(struct inode *inode, struct file *file) 938 { 939 if (atomic_dec_and_test(&dlm_monitor_opened)) 940 dlm_stop_lockspaces(); 941 return 0; 942 } 943 944 static const struct file_operations device_fops = { 945 .open = device_open, 946 .release = device_close, 947 .read = device_read, 948 .write = device_write, 949 .poll = device_poll, 950 .owner = THIS_MODULE, 951 }; 952 953 static const struct file_operations ctl_device_fops = { 954 .open = ctl_device_open, 955 .release = ctl_device_close, 956 .read = device_read, 957 .write = device_write, 958 .owner = THIS_MODULE, 959 }; 960 961 static struct miscdevice ctl_device = { 962 .name = "dlm-control", 963 .fops = &ctl_device_fops, 964 .minor = MISC_DYNAMIC_MINOR, 965 }; 966 967 static const struct file_operations monitor_device_fops = { 968 .open = monitor_device_open, 969 .release = monitor_device_close, 970 .owner = THIS_MODULE, 971 }; 972 973 static struct miscdevice monitor_device = { 974 .name = "dlm-monitor", 975 .fops = &monitor_device_fops, 976 .minor = MISC_DYNAMIC_MINOR, 977 }; 978 979 int __init dlm_user_init(void) 980 { 981 int error; 982 983 atomic_set(&dlm_monitor_opened, 0); 984 985 error = misc_register(&ctl_device); 986 if (error) { 987 log_print("misc_register failed for control device"); 988 goto out; 989 } 990 991 error = misc_register(&monitor_device); 992 if (error) { 993 log_print("misc_register failed for monitor device"); 994 misc_deregister(&ctl_device); 995 } 996 out: 997 return error; 998 } 999 1000 void dlm_user_exit(void) 1001 { 1002 misc_deregister(&ctl_device); 1003 misc_deregister(&monitor_device); 1004 } 1005 1006