fs/orangefs/devorangefs-req.c

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