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