1 /* 2 * (C) 2001 Clemson University and The University of Chicago 3 * 4 * Changes by Acxiom Corporation to add protocol version to kernel 5 * communication, Copyright Acxiom Corporation, 2005. 6 * 7 * See COPYING in top-level directory. 8 */ 9 10 #include "protocol.h" 11 #include "orangefs-kernel.h" 12 #include "orangefs-dev-proto.h" 13 #include "orangefs-bufmap.h" 14 #include "orangefs-debugfs.h" 15 16 #include <linux/debugfs.h> 17 #include <linux/slab.h> 18 19 /* this file implements the /dev/pvfs2-req device node */ 20 21 uint32_t orangefs_userspace_version; 22 23 static int open_access_count; 24 25 static DEFINE_MUTEX(devreq_mutex); 26 27 #define DUMP_DEVICE_ERROR() \ 28 do { \ 29 gossip_err("*****************************************************\n");\ 30 gossip_err("ORANGEFS Device Error: You cannot open the device file "); \ 31 gossip_err("\n/dev/%s more than once. Please make sure that\nthere " \ 32 "are no ", ORANGEFS_REQDEVICE_NAME); \ 33 gossip_err("instances of a program using this device\ncurrently " \ 34 "running. (You must verify this!)\n"); \ 35 gossip_err("For example, you can use the lsof program as follows:\n");\ 36 gossip_err("'lsof | grep %s' (run this as root)\n", \ 37 ORANGEFS_REQDEVICE_NAME); \ 38 gossip_err(" open_access_count = %d\n", open_access_count); \ 39 gossip_err("*****************************************************\n");\ 40 } while (0) 41 42 static int hash_func(__u64 tag, int table_size) 43 { 44 return do_div(tag, (unsigned int)table_size); 45 } 46 47 static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op) 48 { 49 int index = hash_func(op->tag, hash_table_size); 50 51 list_add_tail(&op->list, &orangefs_htable_ops_in_progress[index]); 52 } 53 54 /* 55 * find the op with this tag and remove it from the in progress 56 * hash table. 57 */ 58 static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag) 59 { 60 struct orangefs_kernel_op_s *op, *next; 61 int index; 62 63 index = hash_func(tag, hash_table_size); 64 65 spin_lock(&orangefs_htable_ops_in_progress_lock); 66 list_for_each_entry_safe(op, 67 next, 68 &orangefs_htable_ops_in_progress[index], 69 list) { 70 if (op->tag == tag && !op_state_purged(op) && 71 !op_state_given_up(op)) { 72 list_del_init(&op->list); 73 spin_unlock(&orangefs_htable_ops_in_progress_lock); 74 return op; 75 } 76 } 77 78 spin_unlock(&orangefs_htable_ops_in_progress_lock); 79 return NULL; 80 } 81 82 /* Returns whether any FS are still pending remounted */ 83 static int mark_all_pending_mounts(void) 84 { 85 int unmounted = 1; 86 struct orangefs_sb_info_s *orangefs_sb = NULL; 87 88 spin_lock(&orangefs_superblocks_lock); 89 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { 90 /* All of these file system require a remount */ 91 orangefs_sb->mount_pending = 1; 92 unmounted = 0; 93 } 94 spin_unlock(&orangefs_superblocks_lock); 95 return unmounted; 96 } 97 98 /* 99 * Determine if a given file system needs to be remounted or not 100 * Returns -1 on error 101 * 0 if already mounted 102 * 1 if needs remount 103 */ 104 static int fs_mount_pending(__s32 fsid) 105 { 106 int mount_pending = -1; 107 struct orangefs_sb_info_s *orangefs_sb = NULL; 108 109 spin_lock(&orangefs_superblocks_lock); 110 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { 111 if (orangefs_sb->fs_id == fsid) { 112 mount_pending = orangefs_sb->mount_pending; 113 break; 114 } 115 } 116 spin_unlock(&orangefs_superblocks_lock); 117 return mount_pending; 118 } 119 120 static int orangefs_devreq_open(struct inode *inode, struct file *file) 121 { 122 int ret = -EINVAL; 123 124 /* in order to ensure that the filesystem driver sees correct UIDs */ 125 if (file->f_cred->user_ns != &init_user_ns) { 126 gossip_err("%s: device cannot be opened outside init_user_ns\n", 127 __func__); 128 goto out; 129 } 130 131 if (!(file->f_flags & O_NONBLOCK)) { 132 gossip_err("%s: device cannot be opened in blocking mode\n", 133 __func__); 134 goto out; 135 } 136 ret = -EACCES; 137 gossip_debug(GOSSIP_DEV_DEBUG, "client-core: opening device\n"); 138 mutex_lock(&devreq_mutex); 139 140 if (open_access_count == 0) { 141 open_access_count = 1; 142 ret = 0; 143 } else { 144 DUMP_DEVICE_ERROR(); 145 } 146 mutex_unlock(&devreq_mutex); 147 148 out: 149 150 gossip_debug(GOSSIP_DEV_DEBUG, 151 "pvfs2-client-core: open device complete (ret = %d)\n", 152 ret); 153 return ret; 154 } 155 156 /* Function for read() callers into the device */ 157 static ssize_t orangefs_devreq_read(struct file *file, 158 char __user *buf, 159 size_t count, loff_t *offset) 160 { 161 struct orangefs_kernel_op_s *op, *temp; 162 __s32 proto_ver = ORANGEFS_KERNEL_PROTO_VERSION; 163 static __s32 magic = ORANGEFS_DEVREQ_MAGIC; 164 struct orangefs_kernel_op_s *cur_op = NULL; 165 unsigned long ret; 166 167 /* We do not support blocking IO. */ 168 if (!(file->f_flags & O_NONBLOCK)) { 169 gossip_err("%s: blocking read from client-core.\n", 170 __func__); 171 return -EINVAL; 172 } 173 174 /* 175 * The client will do an ioctl to find MAX_DEV_REQ_UPSIZE, then 176 * always read with that size buffer. 177 */ 178 if (count != MAX_DEV_REQ_UPSIZE) { 179 gossip_err("orangefs: client-core tried to read wrong size\n"); 180 return -EINVAL; 181 } 182 183 restart: 184 /* Get next op (if any) from top of list. */ 185 spin_lock(&orangefs_request_list_lock); 186 list_for_each_entry_safe(op, temp, &orangefs_request_list, list) { 187 __s32 fsid; 188 /* This lock is held past the end of the loop when we break. */ 189 spin_lock(&op->lock); 190 if (unlikely(op_state_purged(op) || op_state_given_up(op))) { 191 spin_unlock(&op->lock); 192 continue; 193 } 194 195 fsid = fsid_of_op(op); 196 if (fsid != ORANGEFS_FS_ID_NULL) { 197 int ret; 198 /* Skip ops whose filesystem needs to be mounted. */ 199 ret = fs_mount_pending(fsid); 200 if (ret == 1) { 201 gossip_debug(GOSSIP_DEV_DEBUG, 202 "%s: mount pending, skipping op tag " 203 "%llu %s\n", 204 __func__, 205 llu(op->tag), 206 get_opname_string(op)); 207 spin_unlock(&op->lock); 208 continue; 209 /* 210 * Skip ops whose filesystem we don't know about unless 211 * it is being mounted. 212 */ 213 /* XXX: is there a better way to detect this? */ 214 } else if (ret == -1 && 215 !(op->upcall.type == 216 ORANGEFS_VFS_OP_FS_MOUNT || 217 op->upcall.type == 218 ORANGEFS_VFS_OP_GETATTR)) { 219 gossip_debug(GOSSIP_DEV_DEBUG, 220 "orangefs: skipping op tag %llu %s\n", 221 llu(op->tag), get_opname_string(op)); 222 gossip_err( 223 "orangefs: ERROR: fs_mount_pending %d\n", 224 fsid); 225 spin_unlock(&op->lock); 226 continue; 227 } 228 } 229 /* 230 * Either this op does not pertain to a filesystem, is mounting 231 * a filesystem, or pertains to a mounted filesystem. Let it 232 * through. 233 */ 234 cur_op = op; 235 break; 236 } 237 238 /* 239 * At this point we either have a valid op and can continue or have not 240 * found an op and must ask the client to try again later. 241 */ 242 if (!cur_op) { 243 spin_unlock(&orangefs_request_list_lock); 244 return -EAGAIN; 245 } 246 247 gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n", 248 __func__, 249 llu(cur_op->tag), 250 get_opname_string(cur_op)); 251 252 /* 253 * Such an op should never be on the list in the first place. If so, we 254 * will abort. 255 */ 256 if (op_state_in_progress(cur_op) || op_state_serviced(cur_op)) { 257 gossip_err("orangefs: ERROR: Current op already queued.\n"); 258 list_del_init(&cur_op->list); 259 spin_unlock(&cur_op->lock); 260 spin_unlock(&orangefs_request_list_lock); 261 return -EAGAIN; 262 } 263 264 list_del_init(&cur_op->list); 265 spin_unlock(&orangefs_request_list_lock); 266 267 spin_unlock(&cur_op->lock); 268 269 /* Push the upcall out. */ 270 ret = copy_to_user(buf, &proto_ver, sizeof(__s32)); 271 if (ret != 0) 272 goto error; 273 ret = copy_to_user(buf+sizeof(__s32), &magic, sizeof(__s32)); 274 if (ret != 0) 275 goto error; 276 ret = copy_to_user(buf+2 * sizeof(__s32), &cur_op->tag, sizeof(__u64)); 277 if (ret != 0) 278 goto error; 279 ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall, 280 sizeof(struct orangefs_upcall_s)); 281 if (ret != 0) 282 goto error; 283 284 spin_lock(&orangefs_htable_ops_in_progress_lock); 285 spin_lock(&cur_op->lock); 286 if (unlikely(op_state_given_up(cur_op))) { 287 spin_unlock(&cur_op->lock); 288 spin_unlock(&orangefs_htable_ops_in_progress_lock); 289 complete(&cur_op->waitq); 290 goto restart; 291 } 292 293 /* 294 * Set the operation to be in progress and move it between lists since 295 * it has been sent to the client. 296 */ 297 set_op_state_inprogress(cur_op); 298 gossip_debug(GOSSIP_DEV_DEBUG, 299 "%s: 1 op:%s: op_state:%d: process:%s:\n", 300 __func__, 301 get_opname_string(cur_op), 302 cur_op->op_state, 303 current->comm); 304 orangefs_devreq_add_op(cur_op); 305 spin_unlock(&cur_op->lock); 306 spin_unlock(&orangefs_htable_ops_in_progress_lock); 307 308 /* The client only asks to read one size buffer. */ 309 return MAX_DEV_REQ_UPSIZE; 310 error: 311 /* 312 * We were unable to copy the op data to the client. Put the op back in 313 * list. If client has crashed, the op will be purged later when the 314 * device is released. 315 */ 316 gossip_err("orangefs: Failed to copy data to user space\n"); 317 spin_lock(&orangefs_request_list_lock); 318 spin_lock(&cur_op->lock); 319 if (likely(!op_state_given_up(cur_op))) { 320 set_op_state_waiting(cur_op); 321 gossip_debug(GOSSIP_DEV_DEBUG, 322 "%s: 2 op:%s: op_state:%d: process:%s:\n", 323 __func__, 324 get_opname_string(cur_op), 325 cur_op->op_state, 326 current->comm); 327 list_add(&cur_op->list, &orangefs_request_list); 328 spin_unlock(&cur_op->lock); 329 } else { 330 spin_unlock(&cur_op->lock); 331 complete(&cur_op->waitq); 332 } 333 spin_unlock(&orangefs_request_list_lock); 334 return -EFAULT; 335 } 336 337 /* 338 * Function for writev() callers into the device. 339 * 340 * Userspace should have written: 341 * - __u32 version 342 * - __u32 magic 343 * - __u64 tag 344 * - struct orangefs_downcall_s 345 * - trailer buffer (in the case of READDIR operations) 346 */ 347 static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb, 348 struct iov_iter *iter) 349 { 350 ssize_t ret; 351 struct orangefs_kernel_op_s *op = NULL; 352 struct { 353 __u32 version; 354 __u32 magic; 355 __u64 tag; 356 } head; 357 int total = ret = iov_iter_count(iter); 358 int downcall_size = sizeof(struct orangefs_downcall_s); 359 int head_size = sizeof(head); 360 361 gossip_debug(GOSSIP_DEV_DEBUG, "%s: total:%d: ret:%zd:\n", 362 __func__, 363 total, 364 ret); 365 366 if (total < MAX_DEV_REQ_DOWNSIZE) { 367 gossip_err("%s: total:%d: must be at least:%u:\n", 368 __func__, 369 total, 370 (unsigned int) MAX_DEV_REQ_DOWNSIZE); 371 return -EFAULT; 372 } 373 374 if (!copy_from_iter_full(&head, head_size, iter)) { 375 gossip_err("%s: failed to copy head.\n", __func__); 376 return -EFAULT; 377 } 378 379 if (head.version < ORANGEFS_MINIMUM_USERSPACE_VERSION) { 380 gossip_err("%s: userspace claims version" 381 "%d, minimum version required: %d.\n", 382 __func__, 383 head.version, 384 ORANGEFS_MINIMUM_USERSPACE_VERSION); 385 return -EPROTO; 386 } 387 388 if (head.magic != ORANGEFS_DEVREQ_MAGIC) { 389 gossip_err("Error: Device magic number does not match.\n"); 390 return -EPROTO; 391 } 392 393 if (!orangefs_userspace_version) { 394 orangefs_userspace_version = head.version; 395 } else if (orangefs_userspace_version != head.version) { 396 gossip_err("Error: userspace version changes\n"); 397 return -EPROTO; 398 } 399 400 /* remove the op from the in progress hash table */ 401 op = orangefs_devreq_remove_op(head.tag); 402 if (!op) { 403 gossip_debug(GOSSIP_DEV_DEBUG, 404 "%s: No one's waiting for tag %llu\n", 405 __func__, llu(head.tag)); 406 return ret; 407 } 408 409 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) { 410 gossip_err("%s: failed to copy downcall.\n", __func__); 411 goto Efault; 412 } 413 414 if (op->downcall.status) 415 goto wakeup; 416 417 /* 418 * We've successfully peeled off the head and the downcall. 419 * Something has gone awry if total doesn't equal the 420 * sum of head_size, downcall_size and trailer_size. 421 */ 422 if ((head_size + downcall_size + op->downcall.trailer_size) != total) { 423 gossip_err("%s: funky write, head_size:%d" 424 ": downcall_size:%d: trailer_size:%lld" 425 ": total size:%d:\n", 426 __func__, 427 head_size, 428 downcall_size, 429 op->downcall.trailer_size, 430 total); 431 goto Efault; 432 } 433 434 /* Only READDIR operations should have trailers. */ 435 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) && 436 (op->downcall.trailer_size != 0)) { 437 gossip_err("%s: %x operation with trailer.", 438 __func__, 439 op->downcall.type); 440 goto Efault; 441 } 442 443 /* READDIR operations should always have trailers. */ 444 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) && 445 (op->downcall.trailer_size == 0)) { 446 gossip_err("%s: %x operation with no trailer.", 447 __func__, 448 op->downcall.type); 449 goto Efault; 450 } 451 452 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR) 453 goto wakeup; 454 455 op->downcall.trailer_buf = 456 vmalloc(op->downcall.trailer_size); 457 if (op->downcall.trailer_buf == NULL) { 458 gossip_err("%s: failed trailer vmalloc.\n", 459 __func__); 460 goto Enomem; 461 } 462 memset(op->downcall.trailer_buf, 0, op->downcall.trailer_size); 463 if (!copy_from_iter_full(op->downcall.trailer_buf, 464 op->downcall.trailer_size, iter)) { 465 gossip_err("%s: failed to copy trailer.\n", __func__); 466 vfree(op->downcall.trailer_buf); 467 goto Efault; 468 } 469 470 wakeup: 471 /* 472 * Return to vfs waitqueue, and back to service_operation 473 * through wait_for_matching_downcall. 474 */ 475 spin_lock(&op->lock); 476 if (unlikely(op_is_cancel(op))) { 477 spin_unlock(&op->lock); 478 put_cancel(op); 479 } else if (unlikely(op_state_given_up(op))) { 480 spin_unlock(&op->lock); 481 complete(&op->waitq); 482 } else { 483 set_op_state_serviced(op); 484 gossip_debug(GOSSIP_DEV_DEBUG, 485 "%s: op:%s: op_state:%d: process:%s:\n", 486 __func__, 487 get_opname_string(op), 488 op->op_state, 489 current->comm); 490 spin_unlock(&op->lock); 491 } 492 return ret; 493 494 Efault: 495 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9); 496 ret = -EFAULT; 497 goto wakeup; 498 499 Enomem: 500 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8); 501 ret = -ENOMEM; 502 goto wakeup; 503 } 504 505 /* 506 * NOTE: gets called when the last reference to this device is dropped. 507 * Using the open_access_count variable, we enforce a reference count 508 * on this file so that it can be opened by only one process at a time. 509 * the devreq_mutex is used to make sure all i/o has completed 510 * before we call orangefs_bufmap_finalize, and similar such tricky 511 * situations 512 */ 513 static int orangefs_devreq_release(struct inode *inode, struct file *file) 514 { 515 int unmounted = 0; 516 517 gossip_debug(GOSSIP_DEV_DEBUG, 518 "%s:pvfs2-client-core: exiting, closing device\n", 519 __func__); 520 521 mutex_lock(&devreq_mutex); 522 orangefs_bufmap_finalize(); 523 524 open_access_count = -1; 525 526 unmounted = mark_all_pending_mounts(); 527 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n", 528 (unmounted ? "UNMOUNTED" : "MOUNTED")); 529 530 purge_waiting_ops(); 531 purge_inprogress_ops(); 532 533 orangefs_bufmap_run_down(); 534 535 gossip_debug(GOSSIP_DEV_DEBUG, 536 "pvfs2-client-core: device close complete\n"); 537 open_access_count = 0; 538 orangefs_userspace_version = 0; 539 mutex_unlock(&devreq_mutex); 540 return 0; 541 } 542 543 int is_daemon_in_service(void) 544 { 545 int in_service; 546 547 /* 548 * What this function does is checks if client-core is alive 549 * based on the access count we maintain on the device. 550 */ 551 mutex_lock(&devreq_mutex); 552 in_service = open_access_count == 1 ? 0 : -EIO; 553 mutex_unlock(&devreq_mutex); 554 return in_service; 555 } 556 557 bool __is_daemon_in_service(void) 558 { 559 return open_access_count == 1; 560 } 561 562 static inline long check_ioctl_command(unsigned int command) 563 { 564 /* Check for valid ioctl codes */ 565 if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) { 566 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n", 567 command, 568 _IOC_TYPE(command), 569 ORANGEFS_DEV_MAGIC); 570 return -EINVAL; 571 } 572 /* and valid ioctl commands */ 573 if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) { 574 gossip_err("Invalid ioctl command number [%d >= %d]\n", 575 _IOC_NR(command), ORANGEFS_DEV_MAXNR); 576 return -ENOIOCTLCMD; 577 } 578 return 0; 579 } 580 581 static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 582 { 583 static __s32 magic = ORANGEFS_DEVREQ_MAGIC; 584 static __s32 max_up_size = MAX_DEV_REQ_UPSIZE; 585 static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE; 586 struct ORANGEFS_dev_map_desc user_desc; 587 int ret = 0; 588 int upstream_kmod = 1; 589 struct orangefs_sb_info_s *orangefs_sb; 590 591 /* mtmoore: add locking here */ 592 593 switch (command) { 594 case ORANGEFS_DEV_GET_MAGIC: 595 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ? 596 -EIO : 597 0); 598 case ORANGEFS_DEV_GET_MAX_UPSIZE: 599 return ((put_user(max_up_size, 600 (__s32 __user *) arg) == -EFAULT) ? 601 -EIO : 602 0); 603 case ORANGEFS_DEV_GET_MAX_DOWNSIZE: 604 return ((put_user(max_down_size, 605 (__s32 __user *) arg) == -EFAULT) ? 606 -EIO : 607 0); 608 case ORANGEFS_DEV_MAP: 609 ret = copy_from_user(&user_desc, 610 (struct ORANGEFS_dev_map_desc __user *) 611 arg, 612 sizeof(struct ORANGEFS_dev_map_desc)); 613 /* WTF -EIO and not -EFAULT? */ 614 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc); 615 case ORANGEFS_DEV_REMOUNT_ALL: 616 gossip_debug(GOSSIP_DEV_DEBUG, 617 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n", 618 __func__); 619 620 /* 621 * remount all mounted orangefs volumes to regain the lost 622 * dynamic mount tables (if any) -- NOTE: this is done 623 * without keeping the superblock list locked due to the 624 * upcall/downcall waiting. also, the request mutex is 625 * used to ensure that no operations will be serviced until 626 * all of the remounts are serviced (to avoid ops between 627 * mounts to fail) 628 */ 629 ret = mutex_lock_interruptible(&orangefs_request_mutex); 630 if (ret < 0) 631 return ret; 632 gossip_debug(GOSSIP_DEV_DEBUG, 633 "%s: priority remount in progress\n", 634 __func__); 635 spin_lock(&orangefs_superblocks_lock); 636 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { 637 /* 638 * We have to drop the spinlock, so entries can be 639 * removed. They can't be freed, though, so we just 640 * keep the forward pointers and zero the back ones - 641 * that way we can get to the rest of the list. 642 */ 643 if (!orangefs_sb->list.prev) 644 continue; 645 gossip_debug(GOSSIP_DEV_DEBUG, 646 "%s: Remounting SB %p\n", 647 __func__, 648 orangefs_sb); 649 650 spin_unlock(&orangefs_superblocks_lock); 651 ret = orangefs_remount(orangefs_sb); 652 spin_lock(&orangefs_superblocks_lock); 653 if (ret) { 654 gossip_debug(GOSSIP_DEV_DEBUG, 655 "SB %p remount failed\n", 656 orangefs_sb); 657 break; 658 } 659 } 660 spin_unlock(&orangefs_superblocks_lock); 661 gossip_debug(GOSSIP_DEV_DEBUG, 662 "%s: priority remount complete\n", 663 __func__); 664 mutex_unlock(&orangefs_request_mutex); 665 return ret; 666 667 case ORANGEFS_DEV_UPSTREAM: 668 ret = copy_to_user((void __user *)arg, 669 &upstream_kmod, 670 sizeof(upstream_kmod)); 671 672 if (ret != 0) 673 return -EIO; 674 else 675 return ret; 676 677 case ORANGEFS_DEV_CLIENT_MASK: 678 return orangefs_debugfs_new_client_mask((void __user *)arg); 679 case ORANGEFS_DEV_CLIENT_STRING: 680 return orangefs_debugfs_new_client_string((void __user *)arg); 681 case ORANGEFS_DEV_DEBUG: 682 return orangefs_debugfs_new_debug((void __user *)arg); 683 default: 684 return -ENOIOCTLCMD; 685 } 686 return -ENOIOCTLCMD; 687 } 688 689 static long orangefs_devreq_ioctl(struct file *file, 690 unsigned int command, unsigned long arg) 691 { 692 long ret; 693 694 /* Check for properly constructed commands */ 695 ret = check_ioctl_command(command); 696 if (ret < 0) 697 return (int)ret; 698 699 return (int)dispatch_ioctl_command(command, arg); 700 } 701 702 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ 703 704 /* Compat structure for the ORANGEFS_DEV_MAP ioctl */ 705 struct ORANGEFS_dev_map_desc32 { 706 compat_uptr_t ptr; 707 __s32 total_size; 708 __s32 size; 709 __s32 count; 710 }; 711 712 static unsigned long translate_dev_map26(unsigned long args, long *error) 713 { 714 struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args; 715 /* 716 * Depending on the architecture, allocate some space on the 717 * user-call-stack based on our expected layout. 718 */ 719 struct ORANGEFS_dev_map_desc __user *p = 720 compat_alloc_user_space(sizeof(*p)); 721 compat_uptr_t addr; 722 723 *error = 0; 724 /* get the ptr from the 32 bit user-space */ 725 if (get_user(addr, &p32->ptr)) 726 goto err; 727 /* try to put that into a 64-bit layout */ 728 if (put_user(compat_ptr(addr), &p->ptr)) 729 goto err; 730 /* copy the remaining fields */ 731 if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32))) 732 goto err; 733 if (copy_in_user(&p->size, &p32->size, sizeof(__s32))) 734 goto err; 735 if (copy_in_user(&p->count, &p32->count, sizeof(__s32))) 736 goto err; 737 return (unsigned long)p; 738 err: 739 *error = -EFAULT; 740 return 0; 741 } 742 743 /* 744 * 32 bit user-space apps' ioctl handlers when kernel modules 745 * is compiled as a 64 bit one 746 */ 747 static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd, 748 unsigned long args) 749 { 750 long ret; 751 unsigned long arg = args; 752 753 /* Check for properly constructed commands */ 754 ret = check_ioctl_command(cmd); 755 if (ret < 0) 756 return ret; 757 if (cmd == ORANGEFS_DEV_MAP) { 758 /* 759 * convert the arguments to what we expect internally 760 * in kernel space 761 */ 762 arg = translate_dev_map26(args, &ret); 763 if (ret < 0) { 764 gossip_err("Could not translate dev map\n"); 765 return ret; 766 } 767 } 768 /* no other ioctl requires translation */ 769 return dispatch_ioctl_command(cmd, arg); 770 } 771 772 #endif /* CONFIG_COMPAT is in .config */ 773 774 /* the assigned character device major number */ 775 static int orangefs_dev_major; 776 777 /* 778 * Initialize orangefs device specific state: 779 * Must be called at module load time only 780 */ 781 int orangefs_dev_init(void) 782 { 783 /* register orangefs-req device */ 784 orangefs_dev_major = register_chrdev(0, 785 ORANGEFS_REQDEVICE_NAME, 786 &orangefs_devreq_file_operations); 787 if (orangefs_dev_major < 0) { 788 gossip_debug(GOSSIP_DEV_DEBUG, 789 "Failed to register /dev/%s (error %d)\n", 790 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major); 791 return orangefs_dev_major; 792 } 793 794 gossip_debug(GOSSIP_DEV_DEBUG, 795 "*** /dev/%s character device registered ***\n", 796 ORANGEFS_REQDEVICE_NAME); 797 gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n", 798 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major); 799 return 0; 800 } 801 802 void orangefs_dev_cleanup(void) 803 { 804 unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME); 805 gossip_debug(GOSSIP_DEV_DEBUG, 806 "*** /dev/%s character device unregistered ***\n", 807 ORANGEFS_REQDEVICE_NAME); 808 } 809 810 static unsigned int orangefs_devreq_poll(struct file *file, 811 struct poll_table_struct *poll_table) 812 { 813 int poll_revent_mask = 0; 814 815 poll_wait(file, &orangefs_request_list_waitq, poll_table); 816 817 if (!list_empty(&orangefs_request_list)) 818 poll_revent_mask |= POLL_IN; 819 return poll_revent_mask; 820 } 821 822 const struct file_operations orangefs_devreq_file_operations = { 823 .owner = THIS_MODULE, 824 .read = orangefs_devreq_read, 825 .write_iter = orangefs_devreq_write_iter, 826 .open = orangefs_devreq_open, 827 .release = orangefs_devreq_release, 828 .unlocked_ioctl = orangefs_devreq_ioctl, 829 830 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ 831 .compat_ioctl = orangefs_devreq_compat_ioctl, 832 #endif 833 .poll = orangefs_devreq_poll 834 }; 835