1 /* 2 * Copyright (C) 2006 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 struct miscdevice ctl_device; 29 static const struct file_operations device_fops; 30 31 #ifdef CONFIG_COMPAT 32 33 struct dlm_lock_params32 { 34 __u8 mode; 35 __u8 namelen; 36 __u16 flags; 37 __u32 lkid; 38 __u32 parent; 39 40 __u32 castparam; 41 __u32 castaddr; 42 __u32 bastparam; 43 __u32 bastaddr; 44 __u32 lksb; 45 46 char lvb[DLM_USER_LVB_LEN]; 47 char name[0]; 48 }; 49 50 struct dlm_write_request32 { 51 __u32 version[3]; 52 __u8 cmd; 53 __u8 is64bit; 54 __u8 unused[2]; 55 56 union { 57 struct dlm_lock_params32 lock; 58 struct dlm_lspace_params lspace; 59 } i; 60 }; 61 62 struct dlm_lksb32 { 63 __u32 sb_status; 64 __u32 sb_lkid; 65 __u8 sb_flags; 66 __u32 sb_lvbptr; 67 }; 68 69 struct dlm_lock_result32 { 70 __u32 length; 71 __u32 user_astaddr; 72 __u32 user_astparam; 73 __u32 user_lksb; 74 struct dlm_lksb32 lksb; 75 __u8 bast_mode; 76 __u8 unused[3]; 77 /* Offsets may be zero if no data is present */ 78 __u32 lvb_offset; 79 }; 80 81 static void compat_input(struct dlm_write_request *kb, 82 struct dlm_write_request32 *kb32) 83 { 84 kb->version[0] = kb32->version[0]; 85 kb->version[1] = kb32->version[1]; 86 kb->version[2] = kb32->version[2]; 87 88 kb->cmd = kb32->cmd; 89 kb->is64bit = kb32->is64bit; 90 if (kb->cmd == DLM_USER_CREATE_LOCKSPACE || 91 kb->cmd == DLM_USER_REMOVE_LOCKSPACE) { 92 kb->i.lspace.flags = kb32->i.lspace.flags; 93 kb->i.lspace.minor = kb32->i.lspace.minor; 94 strcpy(kb->i.lspace.name, kb32->i.lspace.name); 95 } else { 96 kb->i.lock.mode = kb32->i.lock.mode; 97 kb->i.lock.namelen = kb32->i.lock.namelen; 98 kb->i.lock.flags = kb32->i.lock.flags; 99 kb->i.lock.lkid = kb32->i.lock.lkid; 100 kb->i.lock.parent = kb32->i.lock.parent; 101 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam; 102 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr; 103 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam; 104 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr; 105 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb; 106 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN); 107 memcpy(kb->i.lock.name, kb32->i.lock.name, kb->i.lock.namelen); 108 } 109 } 110 111 static void compat_output(struct dlm_lock_result *res, 112 struct dlm_lock_result32 *res32) 113 { 114 res32->length = res->length - (sizeof(struct dlm_lock_result) - 115 sizeof(struct dlm_lock_result32)); 116 res32->user_astaddr = (__u32)(long)res->user_astaddr; 117 res32->user_astparam = (__u32)(long)res->user_astparam; 118 res32->user_lksb = (__u32)(long)res->user_lksb; 119 res32->bast_mode = res->bast_mode; 120 121 res32->lvb_offset = res->lvb_offset; 122 res32->length = res->length; 123 124 res32->lksb.sb_status = res->lksb.sb_status; 125 res32->lksb.sb_flags = res->lksb.sb_flags; 126 res32->lksb.sb_lkid = res->lksb.sb_lkid; 127 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr; 128 } 129 #endif 130 131 132 void dlm_user_add_ast(struct dlm_lkb *lkb, int type) 133 { 134 struct dlm_ls *ls; 135 struct dlm_user_args *ua; 136 struct dlm_user_proc *proc; 137 int remove_ownqueue = 0; 138 139 /* dlm_clear_proc_locks() sets ORPHAN/DEAD flag on each 140 lkb before dealing with it. We need to check this 141 flag before taking ls_clear_proc_locks mutex because if 142 it's set, dlm_clear_proc_locks() holds the mutex. */ 143 144 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) { 145 /* log_print("user_add_ast skip1 %x", lkb->lkb_flags); */ 146 return; 147 } 148 149 ls = lkb->lkb_resource->res_ls; 150 mutex_lock(&ls->ls_clear_proc_locks); 151 152 /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast 153 can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed 154 lkb->ua so we can't try to use it. */ 155 156 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) { 157 /* log_print("user_add_ast skip2 %x", lkb->lkb_flags); */ 158 goto out; 159 } 160 161 DLM_ASSERT(lkb->lkb_astparam, dlm_print_lkb(lkb);); 162 ua = (struct dlm_user_args *)lkb->lkb_astparam; 163 proc = ua->proc; 164 165 if (type == AST_BAST && ua->bastaddr == NULL) 166 goto out; 167 168 spin_lock(&proc->asts_spin); 169 if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) { 170 kref_get(&lkb->lkb_ref); 171 list_add_tail(&lkb->lkb_astqueue, &proc->asts); 172 lkb->lkb_ast_type |= type; 173 wake_up_interruptible(&proc->wait); 174 } 175 176 /* noqueue requests that fail may need to be removed from the 177 proc's locks list, there should be a better way of detecting 178 this situation than checking all these things... */ 179 180 if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV && 181 ua->lksb.sb_status == -EAGAIN && !list_empty(&lkb->lkb_ownqueue)) 182 remove_ownqueue = 1; 183 184 /* unlocks or cancels of waiting requests need to be removed from the 185 proc's unlocking list, again there must be a better way... */ 186 187 if (ua->lksb.sb_status == -DLM_EUNLOCK || 188 (ua->lksb.sb_status == -DLM_ECANCEL && 189 lkb->lkb_grmode == DLM_LOCK_IV)) 190 remove_ownqueue = 1; 191 192 /* We want to copy the lvb to userspace when the completion 193 ast is read if the status is 0, the lock has an lvb and 194 lvb_ops says we should. We could probably have set_lvb_lock() 195 set update_user_lvb instead and not need old_mode */ 196 197 if ((lkb->lkb_ast_type & AST_COMP) && 198 (lkb->lkb_lksb->sb_status == 0) && 199 lkb->lkb_lksb->sb_lvbptr && 200 dlm_lvb_operations[ua->old_mode + 1][lkb->lkb_grmode + 1]) 201 ua->update_user_lvb = 1; 202 else 203 ua->update_user_lvb = 0; 204 205 spin_unlock(&proc->asts_spin); 206 207 if (remove_ownqueue) { 208 spin_lock(&ua->proc->locks_spin); 209 list_del_init(&lkb->lkb_ownqueue); 210 spin_unlock(&ua->proc->locks_spin); 211 dlm_put_lkb(lkb); 212 } 213 out: 214 mutex_unlock(&ls->ls_clear_proc_locks); 215 } 216 217 static int device_user_lock(struct dlm_user_proc *proc, 218 struct dlm_lock_params *params) 219 { 220 struct dlm_ls *ls; 221 struct dlm_user_args *ua; 222 int error = -ENOMEM; 223 224 ls = dlm_find_lockspace_local(proc->lockspace); 225 if (!ls) 226 return -ENOENT; 227 228 if (!params->castaddr || !params->lksb) { 229 error = -EINVAL; 230 goto out; 231 } 232 233 ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL); 234 if (!ua) 235 goto out; 236 ua->proc = proc; 237 ua->user_lksb = params->lksb; 238 ua->castparam = params->castparam; 239 ua->castaddr = params->castaddr; 240 ua->bastparam = params->bastparam; 241 ua->bastaddr = params->bastaddr; 242 243 if (params->flags & DLM_LKF_CONVERT) 244 error = dlm_user_convert(ls, ua, 245 params->mode, params->flags, 246 params->lkid, params->lvb); 247 else { 248 error = dlm_user_request(ls, ua, 249 params->mode, params->flags, 250 params->name, params->namelen, 251 params->parent); 252 if (!error) 253 error = ua->lksb.sb_lkid; 254 } 255 out: 256 dlm_put_lockspace(ls); 257 return error; 258 } 259 260 static int device_user_unlock(struct dlm_user_proc *proc, 261 struct dlm_lock_params *params) 262 { 263 struct dlm_ls *ls; 264 struct dlm_user_args *ua; 265 int error = -ENOMEM; 266 267 ls = dlm_find_lockspace_local(proc->lockspace); 268 if (!ls) 269 return -ENOENT; 270 271 ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL); 272 if (!ua) 273 goto out; 274 ua->proc = proc; 275 ua->user_lksb = params->lksb; 276 ua->castparam = params->castparam; 277 ua->castaddr = params->castaddr; 278 279 if (params->flags & DLM_LKF_CANCEL) 280 error = dlm_user_cancel(ls, ua, params->flags, params->lkid); 281 else 282 error = dlm_user_unlock(ls, ua, params->flags, params->lkid, 283 params->lvb); 284 out: 285 dlm_put_lockspace(ls); 286 return error; 287 } 288 289 static int device_create_lockspace(struct dlm_lspace_params *params) 290 { 291 dlm_lockspace_t *lockspace; 292 struct dlm_ls *ls; 293 int error, len; 294 295 if (!capable(CAP_SYS_ADMIN)) 296 return -EPERM; 297 298 error = dlm_new_lockspace(params->name, strlen(params->name), 299 &lockspace, 0, DLM_USER_LVB_LEN); 300 if (error) 301 return error; 302 303 ls = dlm_find_lockspace_local(lockspace); 304 if (!ls) 305 return -ENOENT; 306 307 error = -ENOMEM; 308 len = strlen(params->name) + strlen(name_prefix) + 2; 309 ls->ls_device.name = kzalloc(len, GFP_KERNEL); 310 if (!ls->ls_device.name) 311 goto fail; 312 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix, 313 params->name); 314 ls->ls_device.fops = &device_fops; 315 ls->ls_device.minor = MISC_DYNAMIC_MINOR; 316 317 error = misc_register(&ls->ls_device); 318 if (error) { 319 kfree(ls->ls_device.name); 320 goto fail; 321 } 322 323 error = ls->ls_device.minor; 324 dlm_put_lockspace(ls); 325 return error; 326 327 fail: 328 dlm_put_lockspace(ls); 329 dlm_release_lockspace(lockspace, 0); 330 return error; 331 } 332 333 static int device_remove_lockspace(struct dlm_lspace_params *params) 334 { 335 dlm_lockspace_t *lockspace; 336 struct dlm_ls *ls; 337 int error, force = 0; 338 339 if (!capable(CAP_SYS_ADMIN)) 340 return -EPERM; 341 342 ls = dlm_find_lockspace_device(params->minor); 343 if (!ls) 344 return -ENOENT; 345 346 error = misc_deregister(&ls->ls_device); 347 if (error) { 348 dlm_put_lockspace(ls); 349 goto out; 350 } 351 kfree(ls->ls_device.name); 352 353 if (params->flags & DLM_USER_LSFLG_FORCEFREE) 354 force = 2; 355 356 lockspace = ls->ls_local_handle; 357 358 /* dlm_release_lockspace waits for references to go to zero, 359 so all processes will need to close their device for the ls 360 before the release will procede */ 361 362 dlm_put_lockspace(ls); 363 error = dlm_release_lockspace(lockspace, force); 364 out: 365 return error; 366 } 367 368 /* Check the user's version matches ours */ 369 static int check_version(struct dlm_write_request *req) 370 { 371 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR || 372 (req->version[0] == DLM_DEVICE_VERSION_MAJOR && 373 req->version[1] > DLM_DEVICE_VERSION_MINOR)) { 374 375 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch " 376 "user (%d.%d.%d) kernel (%d.%d.%d)\n", 377 current->comm, 378 current->pid, 379 req->version[0], 380 req->version[1], 381 req->version[2], 382 DLM_DEVICE_VERSION_MAJOR, 383 DLM_DEVICE_VERSION_MINOR, 384 DLM_DEVICE_VERSION_PATCH); 385 return -EINVAL; 386 } 387 return 0; 388 } 389 390 /* 391 * device_write 392 * 393 * device_user_lock 394 * dlm_user_request -> request_lock 395 * dlm_user_convert -> convert_lock 396 * 397 * device_user_unlock 398 * dlm_user_unlock -> unlock_lock 399 * dlm_user_cancel -> cancel_lock 400 * 401 * device_create_lockspace 402 * dlm_new_lockspace 403 * 404 * device_remove_lockspace 405 * dlm_release_lockspace 406 */ 407 408 /* a write to a lockspace device is a lock or unlock request, a write 409 to the control device is to create/remove a lockspace */ 410 411 static ssize_t device_write(struct file *file, const char __user *buf, 412 size_t count, loff_t *ppos) 413 { 414 struct dlm_user_proc *proc = file->private_data; 415 struct dlm_write_request *kbuf; 416 sigset_t tmpsig, allsigs; 417 int error; 418 419 #ifdef CONFIG_COMPAT 420 if (count < sizeof(struct dlm_write_request32)) 421 #else 422 if (count < sizeof(struct dlm_write_request)) 423 #endif 424 return -EINVAL; 425 426 kbuf = kmalloc(count, GFP_KERNEL); 427 if (!kbuf) 428 return -ENOMEM; 429 430 if (copy_from_user(kbuf, buf, count)) { 431 error = -EFAULT; 432 goto out_free; 433 } 434 435 if (check_version(kbuf)) { 436 error = -EBADE; 437 goto out_free; 438 } 439 440 #ifdef CONFIG_COMPAT 441 if (!kbuf->is64bit) { 442 struct dlm_write_request32 *k32buf; 443 k32buf = (struct dlm_write_request32 *)kbuf; 444 kbuf = kmalloc(count + (sizeof(struct dlm_write_request) - 445 sizeof(struct dlm_write_request32)), GFP_KERNEL); 446 if (!kbuf) 447 return -ENOMEM; 448 449 if (proc) 450 set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags); 451 compat_input(kbuf, k32buf); 452 kfree(k32buf); 453 } 454 #endif 455 456 /* do we really need this? can a write happen after a close? */ 457 if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) && 458 test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags)) 459 return -EINVAL; 460 461 sigfillset(&allsigs); 462 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig); 463 464 error = -EINVAL; 465 466 switch (kbuf->cmd) 467 { 468 case DLM_USER_LOCK: 469 if (!proc) { 470 log_print("no locking on control device"); 471 goto out_sig; 472 } 473 error = device_user_lock(proc, &kbuf->i.lock); 474 break; 475 476 case DLM_USER_UNLOCK: 477 if (!proc) { 478 log_print("no locking on control device"); 479 goto out_sig; 480 } 481 error = device_user_unlock(proc, &kbuf->i.lock); 482 break; 483 484 case DLM_USER_CREATE_LOCKSPACE: 485 if (proc) { 486 log_print("create/remove only on control device"); 487 goto out_sig; 488 } 489 error = device_create_lockspace(&kbuf->i.lspace); 490 break; 491 492 case DLM_USER_REMOVE_LOCKSPACE: 493 if (proc) { 494 log_print("create/remove only on control device"); 495 goto out_sig; 496 } 497 error = device_remove_lockspace(&kbuf->i.lspace); 498 break; 499 500 default: 501 log_print("Unknown command passed to DLM device : %d\n", 502 kbuf->cmd); 503 } 504 505 out_sig: 506 sigprocmask(SIG_SETMASK, &tmpsig, NULL); 507 recalc_sigpending(); 508 out_free: 509 kfree(kbuf); 510 return error; 511 } 512 513 /* Every process that opens the lockspace device has its own "proc" structure 514 hanging off the open file that's used to keep track of locks owned by the 515 process and asts that need to be delivered to the process. */ 516 517 static int device_open(struct inode *inode, struct file *file) 518 { 519 struct dlm_user_proc *proc; 520 struct dlm_ls *ls; 521 522 ls = dlm_find_lockspace_device(iminor(inode)); 523 if (!ls) 524 return -ENOENT; 525 526 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_KERNEL); 527 if (!proc) { 528 dlm_put_lockspace(ls); 529 return -ENOMEM; 530 } 531 532 proc->lockspace = ls->ls_local_handle; 533 INIT_LIST_HEAD(&proc->asts); 534 INIT_LIST_HEAD(&proc->locks); 535 INIT_LIST_HEAD(&proc->unlocking); 536 spin_lock_init(&proc->asts_spin); 537 spin_lock_init(&proc->locks_spin); 538 init_waitqueue_head(&proc->wait); 539 file->private_data = proc; 540 541 return 0; 542 } 543 544 static int device_close(struct inode *inode, struct file *file) 545 { 546 struct dlm_user_proc *proc = file->private_data; 547 struct dlm_ls *ls; 548 sigset_t tmpsig, allsigs; 549 550 ls = dlm_find_lockspace_local(proc->lockspace); 551 if (!ls) 552 return -ENOENT; 553 554 sigfillset(&allsigs); 555 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig); 556 557 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags); 558 559 dlm_clear_proc_locks(ls, proc); 560 561 /* at this point no more lkb's should exist for this lockspace, 562 so there's no chance of dlm_user_add_ast() being called and 563 looking for lkb->ua->proc */ 564 565 kfree(proc); 566 file->private_data = NULL; 567 568 dlm_put_lockspace(ls); 569 dlm_put_lockspace(ls); /* for the find in device_open() */ 570 571 /* FIXME: AUTOFREE: if this ls is no longer used do 572 device_remove_lockspace() */ 573 574 sigprocmask(SIG_SETMASK, &tmpsig, NULL); 575 recalc_sigpending(); 576 577 return 0; 578 } 579 580 static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type, 581 int bmode, char __user *buf, size_t count) 582 { 583 #ifdef CONFIG_COMPAT 584 struct dlm_lock_result32 result32; 585 #endif 586 struct dlm_lock_result result; 587 void *resultptr; 588 int error=0; 589 int len; 590 int struct_len; 591 592 memset(&result, 0, sizeof(struct dlm_lock_result)); 593 memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb)); 594 result.user_lksb = ua->user_lksb; 595 596 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated 597 in a conversion unless the conversion is successful. See code 598 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though, 599 notes that a new blocking AST address and parameter are set even if 600 the conversion fails, so maybe we should just do that. */ 601 602 if (type == AST_BAST) { 603 result.user_astaddr = ua->bastaddr; 604 result.user_astparam = ua->bastparam; 605 result.bast_mode = bmode; 606 } else { 607 result.user_astaddr = ua->castaddr; 608 result.user_astparam = ua->castparam; 609 } 610 611 #ifdef CONFIG_COMPAT 612 if (compat) 613 len = sizeof(struct dlm_lock_result32); 614 else 615 #endif 616 len = sizeof(struct dlm_lock_result); 617 struct_len = len; 618 619 /* copy lvb to userspace if there is one, it's been updated, and 620 the user buffer has space for it */ 621 622 if (ua->update_user_lvb && ua->lksb.sb_lvbptr && 623 count >= len + DLM_USER_LVB_LEN) { 624 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr, 625 DLM_USER_LVB_LEN)) { 626 error = -EFAULT; 627 goto out; 628 } 629 630 result.lvb_offset = len; 631 len += DLM_USER_LVB_LEN; 632 } 633 634 result.length = len; 635 resultptr = &result; 636 #ifdef CONFIG_COMPAT 637 if (compat) { 638 compat_output(&result, &result32); 639 resultptr = &result32; 640 } 641 #endif 642 643 if (copy_to_user(buf, resultptr, struct_len)) 644 error = -EFAULT; 645 else 646 error = len; 647 out: 648 return error; 649 } 650 651 /* a read returns a single ast described in a struct dlm_lock_result */ 652 653 static ssize_t device_read(struct file *file, char __user *buf, size_t count, 654 loff_t *ppos) 655 { 656 struct dlm_user_proc *proc = file->private_data; 657 struct dlm_lkb *lkb; 658 struct dlm_user_args *ua; 659 DECLARE_WAITQUEUE(wait, current); 660 int error, type=0, bmode=0, removed = 0; 661 662 #ifdef CONFIG_COMPAT 663 if (count < sizeof(struct dlm_lock_result32)) 664 #else 665 if (count < sizeof(struct dlm_lock_result)) 666 #endif 667 return -EINVAL; 668 669 /* do we really need this? can a read happen after a close? */ 670 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags)) 671 return -EINVAL; 672 673 spin_lock(&proc->asts_spin); 674 if (list_empty(&proc->asts)) { 675 if (file->f_flags & O_NONBLOCK) { 676 spin_unlock(&proc->asts_spin); 677 return -EAGAIN; 678 } 679 680 add_wait_queue(&proc->wait, &wait); 681 682 repeat: 683 set_current_state(TASK_INTERRUPTIBLE); 684 if (list_empty(&proc->asts) && !signal_pending(current)) { 685 spin_unlock(&proc->asts_spin); 686 schedule(); 687 spin_lock(&proc->asts_spin); 688 goto repeat; 689 } 690 set_current_state(TASK_RUNNING); 691 remove_wait_queue(&proc->wait, &wait); 692 693 if (signal_pending(current)) { 694 spin_unlock(&proc->asts_spin); 695 return -ERESTARTSYS; 696 } 697 } 698 699 if (list_empty(&proc->asts)) { 700 spin_unlock(&proc->asts_spin); 701 return -EAGAIN; 702 } 703 704 /* there may be both completion and blocking asts to return for 705 the lkb, don't remove lkb from asts list unless no asts remain */ 706 707 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_astqueue); 708 709 if (lkb->lkb_ast_type & AST_COMP) { 710 lkb->lkb_ast_type &= ~AST_COMP; 711 type = AST_COMP; 712 } else if (lkb->lkb_ast_type & AST_BAST) { 713 lkb->lkb_ast_type &= ~AST_BAST; 714 type = AST_BAST; 715 bmode = lkb->lkb_bastmode; 716 } 717 718 if (!lkb->lkb_ast_type) { 719 list_del(&lkb->lkb_astqueue); 720 removed = 1; 721 } 722 spin_unlock(&proc->asts_spin); 723 724 ua = (struct dlm_user_args *)lkb->lkb_astparam; 725 error = copy_result_to_user(ua, 726 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags), 727 type, bmode, buf, count); 728 729 /* removes reference for the proc->asts lists added by 730 dlm_user_add_ast() and may result in the lkb being freed */ 731 if (removed) 732 dlm_put_lkb(lkb); 733 734 return error; 735 } 736 737 static unsigned int device_poll(struct file *file, poll_table *wait) 738 { 739 struct dlm_user_proc *proc = file->private_data; 740 741 poll_wait(file, &proc->wait, wait); 742 743 spin_lock(&proc->asts_spin); 744 if (!list_empty(&proc->asts)) { 745 spin_unlock(&proc->asts_spin); 746 return POLLIN | POLLRDNORM; 747 } 748 spin_unlock(&proc->asts_spin); 749 return 0; 750 } 751 752 static int ctl_device_open(struct inode *inode, struct file *file) 753 { 754 file->private_data = NULL; 755 return 0; 756 } 757 758 static int ctl_device_close(struct inode *inode, struct file *file) 759 { 760 return 0; 761 } 762 763 static const struct file_operations device_fops = { 764 .open = device_open, 765 .release = device_close, 766 .read = device_read, 767 .write = device_write, 768 .poll = device_poll, 769 .owner = THIS_MODULE, 770 }; 771 772 static const struct file_operations ctl_device_fops = { 773 .open = ctl_device_open, 774 .release = ctl_device_close, 775 .write = device_write, 776 .owner = THIS_MODULE, 777 }; 778 779 int dlm_user_init(void) 780 { 781 int error; 782 783 ctl_device.name = "dlm-control"; 784 ctl_device.fops = &ctl_device_fops; 785 ctl_device.minor = MISC_DYNAMIC_MINOR; 786 787 error = misc_register(&ctl_device); 788 if (error) 789 log_print("misc_register failed for control device"); 790 791 return error; 792 } 793 794 void dlm_user_exit(void) 795 { 796 misc_deregister(&ctl_device); 797 } 798 799