fs/orangefs/devorangefs-req.c

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