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_err("WARNING: No one's waiting for tag %llu\n", 404 llu(head.tag)); 405 return ret; 406 } 407 408 if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) { 409 gossip_err("%s: failed to copy downcall.\n", __func__); 410 goto Efault; 411 } 412 413 if (op->downcall.status) 414 goto wakeup; 415 416 /* 417 * We've successfully peeled off the head and the downcall. 418 * Something has gone awry if total doesn't equal the 419 * sum of head_size, downcall_size and trailer_size. 420 */ 421 if ((head_size + downcall_size + op->downcall.trailer_size) != total) { 422 gossip_err("%s: funky write, head_size:%d" 423 ": downcall_size:%d: trailer_size:%lld" 424 ": total size:%d:\n", 425 __func__, 426 head_size, 427 downcall_size, 428 op->downcall.trailer_size, 429 total); 430 goto Efault; 431 } 432 433 /* Only READDIR operations should have trailers. */ 434 if ((op->downcall.type != ORANGEFS_VFS_OP_READDIR) && 435 (op->downcall.trailer_size != 0)) { 436 gossip_err("%s: %x operation with trailer.", 437 __func__, 438 op->downcall.type); 439 goto Efault; 440 } 441 442 /* READDIR operations should always have trailers. */ 443 if ((op->downcall.type == ORANGEFS_VFS_OP_READDIR) && 444 (op->downcall.trailer_size == 0)) { 445 gossip_err("%s: %x operation with no trailer.", 446 __func__, 447 op->downcall.type); 448 goto Efault; 449 } 450 451 if (op->downcall.type != ORANGEFS_VFS_OP_READDIR) 452 goto wakeup; 453 454 op->downcall.trailer_buf = 455 vmalloc(op->downcall.trailer_size); 456 if (op->downcall.trailer_buf == NULL) { 457 gossip_err("%s: failed trailer vmalloc.\n", 458 __func__); 459 goto Enomem; 460 } 461 memset(op->downcall.trailer_buf, 0, op->downcall.trailer_size); 462 if (!copy_from_iter_full(op->downcall.trailer_buf, 463 op->downcall.trailer_size, iter)) { 464 gossip_err("%s: failed to copy trailer.\n", __func__); 465 vfree(op->downcall.trailer_buf); 466 goto Efault; 467 } 468 469 wakeup: 470 /* 471 * Return to vfs waitqueue, and back to service_operation 472 * through wait_for_matching_downcall. 473 */ 474 spin_lock(&op->lock); 475 if (unlikely(op_is_cancel(op))) { 476 spin_unlock(&op->lock); 477 put_cancel(op); 478 } else if (unlikely(op_state_given_up(op))) { 479 spin_unlock(&op->lock); 480 complete(&op->waitq); 481 } else { 482 set_op_state_serviced(op); 483 gossip_debug(GOSSIP_DEV_DEBUG, 484 "%s: op:%s: op_state:%d: process:%s:\n", 485 __func__, 486 get_opname_string(op), 487 op->op_state, 488 current->comm); 489 spin_unlock(&op->lock); 490 } 491 return ret; 492 493 Efault: 494 op->downcall.status = -(ORANGEFS_ERROR_BIT | 9); 495 ret = -EFAULT; 496 goto wakeup; 497 498 Enomem: 499 op->downcall.status = -(ORANGEFS_ERROR_BIT | 8); 500 ret = -ENOMEM; 501 goto wakeup; 502 } 503 504 /* 505 * NOTE: gets called when the last reference to this device is dropped. 506 * Using the open_access_count variable, we enforce a reference count 507 * on this file so that it can be opened by only one process at a time. 508 * the devreq_mutex is used to make sure all i/o has completed 509 * before we call orangefs_bufmap_finalize, and similar such tricky 510 * situations 511 */ 512 static int orangefs_devreq_release(struct inode *inode, struct file *file) 513 { 514 int unmounted = 0; 515 516 gossip_debug(GOSSIP_DEV_DEBUG, 517 "%s:pvfs2-client-core: exiting, closing device\n", 518 __func__); 519 520 mutex_lock(&devreq_mutex); 521 orangefs_bufmap_finalize(); 522 523 open_access_count = -1; 524 525 unmounted = mark_all_pending_mounts(); 526 gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n", 527 (unmounted ? "UNMOUNTED" : "MOUNTED")); 528 529 purge_waiting_ops(); 530 purge_inprogress_ops(); 531 532 orangefs_bufmap_run_down(); 533 534 gossip_debug(GOSSIP_DEV_DEBUG, 535 "pvfs2-client-core: device close complete\n"); 536 open_access_count = 0; 537 orangefs_userspace_version = 0; 538 mutex_unlock(&devreq_mutex); 539 return 0; 540 } 541 542 int is_daemon_in_service(void) 543 { 544 int in_service; 545 546 /* 547 * What this function does is checks if client-core is alive 548 * based on the access count we maintain on the device. 549 */ 550 mutex_lock(&devreq_mutex); 551 in_service = open_access_count == 1 ? 0 : -EIO; 552 mutex_unlock(&devreq_mutex); 553 return in_service; 554 } 555 556 bool __is_daemon_in_service(void) 557 { 558 return open_access_count == 1; 559 } 560 561 static inline long check_ioctl_command(unsigned int command) 562 { 563 /* Check for valid ioctl codes */ 564 if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) { 565 gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n", 566 command, 567 _IOC_TYPE(command), 568 ORANGEFS_DEV_MAGIC); 569 return -EINVAL; 570 } 571 /* and valid ioctl commands */ 572 if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) { 573 gossip_err("Invalid ioctl command number [%d >= %d]\n", 574 _IOC_NR(command), ORANGEFS_DEV_MAXNR); 575 return -ENOIOCTLCMD; 576 } 577 return 0; 578 } 579 580 static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 581 { 582 static __s32 magic = ORANGEFS_DEVREQ_MAGIC; 583 static __s32 max_up_size = MAX_DEV_REQ_UPSIZE; 584 static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE; 585 struct ORANGEFS_dev_map_desc user_desc; 586 int ret = 0; 587 int upstream_kmod = 1; 588 struct orangefs_sb_info_s *orangefs_sb; 589 590 /* mtmoore: add locking here */ 591 592 switch (command) { 593 case ORANGEFS_DEV_GET_MAGIC: 594 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ? 595 -EIO : 596 0); 597 case ORANGEFS_DEV_GET_MAX_UPSIZE: 598 return ((put_user(max_up_size, 599 (__s32 __user *) arg) == -EFAULT) ? 600 -EIO : 601 0); 602 case ORANGEFS_DEV_GET_MAX_DOWNSIZE: 603 return ((put_user(max_down_size, 604 (__s32 __user *) arg) == -EFAULT) ? 605 -EIO : 606 0); 607 case ORANGEFS_DEV_MAP: 608 ret = copy_from_user(&user_desc, 609 (struct ORANGEFS_dev_map_desc __user *) 610 arg, 611 sizeof(struct ORANGEFS_dev_map_desc)); 612 /* WTF -EIO and not -EFAULT? */ 613 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc); 614 case ORANGEFS_DEV_REMOUNT_ALL: 615 gossip_debug(GOSSIP_DEV_DEBUG, 616 "%s: got ORANGEFS_DEV_REMOUNT_ALL\n", 617 __func__); 618 619 /* 620 * remount all mounted orangefs volumes to regain the lost 621 * dynamic mount tables (if any) -- NOTE: this is done 622 * without keeping the superblock list locked due to the 623 * upcall/downcall waiting. also, the request mutex is 624 * used to ensure that no operations will be serviced until 625 * all of the remounts are serviced (to avoid ops between 626 * mounts to fail) 627 */ 628 ret = mutex_lock_interruptible(&orangefs_request_mutex); 629 if (ret < 0) 630 return ret; 631 gossip_debug(GOSSIP_DEV_DEBUG, 632 "%s: priority remount in progress\n", 633 __func__); 634 spin_lock(&orangefs_superblocks_lock); 635 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { 636 /* 637 * We have to drop the spinlock, so entries can be 638 * removed. They can't be freed, though, so we just 639 * keep the forward pointers and zero the back ones - 640 * that way we can get to the rest of the list. 641 */ 642 if (!orangefs_sb->list.prev) 643 continue; 644 gossip_debug(GOSSIP_DEV_DEBUG, 645 "%s: Remounting SB %p\n", 646 __func__, 647 orangefs_sb); 648 649 spin_unlock(&orangefs_superblocks_lock); 650 ret = orangefs_remount(orangefs_sb); 651 spin_lock(&orangefs_superblocks_lock); 652 if (ret) { 653 gossip_debug(GOSSIP_DEV_DEBUG, 654 "SB %p remount failed\n", 655 orangefs_sb); 656 break; 657 } 658 } 659 spin_unlock(&orangefs_superblocks_lock); 660 gossip_debug(GOSSIP_DEV_DEBUG, 661 "%s: priority remount complete\n", 662 __func__); 663 mutex_unlock(&orangefs_request_mutex); 664 return ret; 665 666 case ORANGEFS_DEV_UPSTREAM: 667 ret = copy_to_user((void __user *)arg, 668 &upstream_kmod, 669 sizeof(upstream_kmod)); 670 671 if (ret != 0) 672 return -EIO; 673 else 674 return ret; 675 676 case ORANGEFS_DEV_CLIENT_MASK: 677 return orangefs_debugfs_new_client_mask((void __user *)arg); 678 case ORANGEFS_DEV_CLIENT_STRING: 679 return orangefs_debugfs_new_client_string((void __user *)arg); 680 case ORANGEFS_DEV_DEBUG: 681 return orangefs_debugfs_new_debug((void __user *)arg); 682 default: 683 return -ENOIOCTLCMD; 684 } 685 return -ENOIOCTLCMD; 686 } 687 688 static long orangefs_devreq_ioctl(struct file *file, 689 unsigned int command, unsigned long arg) 690 { 691 long ret; 692 693 /* Check for properly constructed commands */ 694 ret = check_ioctl_command(command); 695 if (ret < 0) 696 return (int)ret; 697 698 return (int)dispatch_ioctl_command(command, arg); 699 } 700 701 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ 702 703 /* Compat structure for the ORANGEFS_DEV_MAP ioctl */ 704 struct ORANGEFS_dev_map_desc32 { 705 compat_uptr_t ptr; 706 __s32 total_size; 707 __s32 size; 708 __s32 count; 709 }; 710 711 static unsigned long translate_dev_map26(unsigned long args, long *error) 712 { 713 struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args; 714 /* 715 * Depending on the architecture, allocate some space on the 716 * user-call-stack based on our expected layout. 717 */ 718 struct ORANGEFS_dev_map_desc __user *p = 719 compat_alloc_user_space(sizeof(*p)); 720 compat_uptr_t addr; 721 722 *error = 0; 723 /* get the ptr from the 32 bit user-space */ 724 if (get_user(addr, &p32->ptr)) 725 goto err; 726 /* try to put that into a 64-bit layout */ 727 if (put_user(compat_ptr(addr), &p->ptr)) 728 goto err; 729 /* copy the remaining fields */ 730 if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32))) 731 goto err; 732 if (copy_in_user(&p->size, &p32->size, sizeof(__s32))) 733 goto err; 734 if (copy_in_user(&p->count, &p32->count, sizeof(__s32))) 735 goto err; 736 return (unsigned long)p; 737 err: 738 *error = -EFAULT; 739 return 0; 740 } 741 742 /* 743 * 32 bit user-space apps' ioctl handlers when kernel modules 744 * is compiled as a 64 bit one 745 */ 746 static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd, 747 unsigned long args) 748 { 749 long ret; 750 unsigned long arg = args; 751 752 /* Check for properly constructed commands */ 753 ret = check_ioctl_command(cmd); 754 if (ret < 0) 755 return ret; 756 if (cmd == ORANGEFS_DEV_MAP) { 757 /* 758 * convert the arguments to what we expect internally 759 * in kernel space 760 */ 761 arg = translate_dev_map26(args, &ret); 762 if (ret < 0) { 763 gossip_err("Could not translate dev map\n"); 764 return ret; 765 } 766 } 767 /* no other ioctl requires translation */ 768 return dispatch_ioctl_command(cmd, arg); 769 } 770 771 #endif /* CONFIG_COMPAT is in .config */ 772 773 /* the assigned character device major number */ 774 static int orangefs_dev_major; 775 776 /* 777 * Initialize orangefs device specific state: 778 * Must be called at module load time only 779 */ 780 int orangefs_dev_init(void) 781 { 782 /* register orangefs-req device */ 783 orangefs_dev_major = register_chrdev(0, 784 ORANGEFS_REQDEVICE_NAME, 785 &orangefs_devreq_file_operations); 786 if (orangefs_dev_major < 0) { 787 gossip_debug(GOSSIP_DEV_DEBUG, 788 "Failed to register /dev/%s (error %d)\n", 789 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major); 790 return orangefs_dev_major; 791 } 792 793 gossip_debug(GOSSIP_DEV_DEBUG, 794 "*** /dev/%s character device registered ***\n", 795 ORANGEFS_REQDEVICE_NAME); 796 gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n", 797 ORANGEFS_REQDEVICE_NAME, orangefs_dev_major); 798 return 0; 799 } 800 801 void orangefs_dev_cleanup(void) 802 { 803 unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME); 804 gossip_debug(GOSSIP_DEV_DEBUG, 805 "*** /dev/%s character device unregistered ***\n", 806 ORANGEFS_REQDEVICE_NAME); 807 } 808 809 static unsigned int orangefs_devreq_poll(struct file *file, 810 struct poll_table_struct *poll_table) 811 { 812 int poll_revent_mask = 0; 813 814 poll_wait(file, &orangefs_request_list_waitq, poll_table); 815 816 if (!list_empty(&orangefs_request_list)) 817 poll_revent_mask |= POLL_IN; 818 return poll_revent_mask; 819 } 820 821 const struct file_operations orangefs_devreq_file_operations = { 822 .owner = THIS_MODULE, 823 .read = orangefs_devreq_read, 824 .write_iter = orangefs_devreq_write_iter, 825 .open = orangefs_devreq_open, 826 .release = orangefs_devreq_release, 827 .unlocked_ioctl = orangefs_devreq_ioctl, 828 829 #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ 830 .compat_ioctl = orangefs_devreq_compat_ioctl, 831 #endif 832 .poll = orangefs_devreq_poll 833 }; 834