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 orangefs_sb_info_s *orangefs_sb;
 576
 577         /* mtmoore: add locking here */
 578
 579         switch (command) {
 580         case ORANGEFS_DEV_GET_MAGIC:
 581                 return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
 582                         -EIO :
 583                         0);
 584         case ORANGEFS_DEV_GET_MAX_UPSIZE:
 585                 return ((put_user(max_up_size,
 586                                   (__s32 __user *) arg) == -EFAULT) ?
 587                                         -EIO :
 588                                         0);
 589         case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
 590                 return ((put_user(max_down_size,
 591                                   (__s32 __user *) arg) == -EFAULT) ?
 592                                         -EIO :
 593                                         0);
 594         case ORANGEFS_DEV_MAP:
 595                 ret = copy_from_user(&user_desc,
 596                                      (struct ORANGEFS_dev_map_desc __user *)
 597                                      arg,
 598                                      sizeof(struct ORANGEFS_dev_map_desc));
 599                 /* WTF -EIO and not -EFAULT? */
 600                 return ret ? -EIO : orangefs_bufmap_initialize(&user_desc);
 601         case ORANGEFS_DEV_REMOUNT_ALL:
 602                 gossip_debug(GOSSIP_DEV_DEBUG,
 603                              "%s: got ORANGEFS_DEV_REMOUNT_ALL\n",
 604                              __func__);
 605
 606                 /*
 607                  * remount all mounted orangefs volumes to regain the lost
 608                  * dynamic mount tables (if any) -- NOTE: this is done
 609                  * without keeping the superblock list locked due to the
 610                  * upcall/downcall waiting.  also, the request mutex is
 611                  * used to ensure that no operations will be serviced until
 612                  * all of the remounts are serviced (to avoid ops between
 613                  * mounts to fail)
 614                  */
 615                 ret = mutex_lock_interruptible(&request_mutex);
 616                 if (ret < 0)
 617                         return ret;
 618                 gossip_debug(GOSSIP_DEV_DEBUG,
 619                              "%s: priority remount in progress\n",
 620                              __func__);
 621                 spin_lock(&orangefs_superblocks_lock);
 622                 list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
 623                         /*
 624                          * We have to drop the spinlock, so entries can be
 625                          * removed.  They can't be freed, though, so we just
 626                          * keep the forward pointers and zero the back ones -
 627                          * that way we can get to the rest of the list.
 628                          */
 629                         if (!orangefs_sb->list.prev)
 630                                 continue;
 631                         gossip_debug(GOSSIP_DEV_DEBUG,
 632                                      "%s: Remounting SB %p\n",
 633                                      __func__,
 634                                      orangefs_sb);
 635
 636                         spin_unlock(&orangefs_superblocks_lock);
 637                         ret = orangefs_remount(orangefs_sb);
 638                         spin_lock(&orangefs_superblocks_lock);
 639                         if (ret) {
 640                                 gossip_debug(GOSSIP_DEV_DEBUG,
 641                                              "SB %p remount failed\n",
 642                                              orangefs_sb);
 643                                 break;
 644                         }
 645                 }
 646                 spin_unlock(&orangefs_superblocks_lock);
 647                 gossip_debug(GOSSIP_DEV_DEBUG,
 648                              "%s: priority remount complete\n",
 649                              __func__);
 650                 mutex_unlock(&request_mutex);
 651                 return ret;
 652
 653         case ORANGEFS_DEV_UPSTREAM:
 654                 ret = copy_to_user((void __user *)arg,
 655                                     &upstream_kmod,
 656                                     sizeof(upstream_kmod));
 657
 658                 if (ret != 0)
 659                         return -EIO;
 660                 else
 661                         return ret;
 662
 663         case ORANGEFS_DEV_CLIENT_MASK:
 664                 ret = copy_from_user(&mask2_info,
 665                                      (void __user *)arg,
 666                                      sizeof(struct dev_mask2_info_s));
 667
 668                 if (ret != 0)
 669                         return -EIO;
 670
 671                 client_debug_mask.mask1 = mask2_info.mask1_value;
 672                 client_debug_mask.mask2 = mask2_info.mask2_value;
 673
 674                 pr_info("%s: client debug mask has been been received "
 675                         ":%llx: :%llx:\n",
 676                         __func__,
 677                         (unsigned long long)client_debug_mask.mask1,
 678                         (unsigned long long)client_debug_mask.mask2);
 679
 680                 return ret;
 681
 682         case ORANGEFS_DEV_CLIENT_STRING:
 683                 ret = copy_from_user(&client_debug_array_string,
 684                                      (void __user *)arg,
 685                                      ORANGEFS_MAX_DEBUG_STRING_LEN);
 686                 /*
 687                  * The real client-core makes an effort to ensure
 688                  * that actual strings that aren't too long to fit in
 689                  * this buffer is what we get here. We're going to use
 690                  * string functions on the stuff we got, so we'll make
 691                  * this extra effort to try and keep from
 692                  * flowing out of this buffer when we use the string
 693                  * functions, even if somehow the stuff we end up
 694                  * with here is garbage.
 695                  */
 696                 client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
 697                         '\0';
 698
 699                 if (ret != 0) {
 700                         pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
 701                                 __func__);
 702                         return -EIO;
 703                 }
 704
 705                 pr_info("%s: client debug array string has been received.\n",
 706                         __func__);
 707
 708                 if (!help_string_initialized) {
 709
 710                         /* Free the "we don't know yet" default string... */
 711                         kfree(debug_help_string);
 712
 713                         /* build a proper debug help string */
 714                         if (orangefs_prepare_debugfs_help_string(0)) {
 715                                 gossip_err("%s: no debug help string \n",
 716                                            __func__);
 717                                 return -EIO;
 718                         }
 719
 720                         /* Replace the boilerplate boot-time debug-help file. */
 721                         debugfs_remove(help_file_dentry);
 722
 723                         help_file_dentry =
 724                                 debugfs_create_file(
 725                                         ORANGEFS_KMOD_DEBUG_HELP_FILE,
 726                                         0444,
 727                                         debug_dir,
 728                                         debug_help_string,
 729                                         &debug_help_fops);
 730
 731                         if (!help_file_dentry) {
 732                                 gossip_err("%s: debugfs_create_file failed for"
 733                                            " :%s:!\n",
 734                                            __func__,
 735                                            ORANGEFS_KMOD_DEBUG_HELP_FILE);
 736                                 return -EIO;
 737                         }
 738                 }
 739
 740                 debug_mask_to_string(&client_debug_mask, 1);
 741
 742                 debugfs_remove(client_debug_dentry);
 743
 744                 orangefs_client_debug_init();
 745
 746                 help_string_initialized++;
 747
 748                 return ret;
 749
 750         case ORANGEFS_DEV_DEBUG:
 751                 ret = copy_from_user(&mask_info,
 752                                      (void __user *)arg,
 753                                      sizeof(mask_info));
 754
 755                 if (ret != 0)
 756                         return -EIO;
 757
 758                 if (mask_info.mask_type == KERNEL_MASK) {
 759                         if ((mask_info.mask_value == 0)
 760                             && (kernel_mask_set_mod_init)) {
 761                                 /*
 762                                  * the kernel debug mask was set when the
 763                                  * kernel module was loaded; don't override
 764                                  * it if the client-core was started without
 765                                  * a value for ORANGEFS_KMODMASK.
 766                                  */
 767                                 return 0;
 768                         }
 769                         debug_mask_to_string(&mask_info.mask_value,
 770                                              mask_info.mask_type);
 771                         gossip_debug_mask = mask_info.mask_value;
 772                         pr_info("%s: kernel debug mask has been modified to "
 773                                 ":%s: :%llx:\n",
 774                                 __func__,
 775                                 kernel_debug_string,
 776                                 (unsigned long long)gossip_debug_mask);
 777                 } else if (mask_info.mask_type == CLIENT_MASK) {
 778                         debug_mask_to_string(&mask_info.mask_value,
 779                                              mask_info.mask_type);
 780                         pr_info("%s: client debug mask has been modified to"
 781                                 ":%s: :%llx:\n",
 782                                 __func__,
 783                                 client_debug_string,
 784                                 llu(mask_info.mask_value));
 785                 } else {
 786                         gossip_lerr("Invalid mask type....\n");
 787                         return -EINVAL;
 788                 }
 789
 790                 return ret;
 791
 792         default:
 793                 return -ENOIOCTLCMD;
 794         }
 795         return -ENOIOCTLCMD;
 796 }
 797
 798 static long orangefs_devreq_ioctl(struct file *file,
 799                                unsigned int command, unsigned long arg)
 800 {
 801         long ret;
 802
 803         /* Check for properly constructed commands */
 804         ret = check_ioctl_command(command);
 805         if (ret < 0)
 806                 return (int)ret;
 807
 808         return (int)dispatch_ioctl_command(command, arg);
 809 }
 810
 811 #ifdef CONFIG_COMPAT            /* CONFIG_COMPAT is in .config */
 812
 813 /*  Compat structure for the ORANGEFS_DEV_MAP ioctl */
 814 struct ORANGEFS_dev_map_desc32 {
 815         compat_uptr_t ptr;
 816         __s32 total_size;
 817         __s32 size;
 818         __s32 count;
 819 };
 820
 821 static unsigned long translate_dev_map26(unsigned long args, long *error)
 822 {
 823         struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
 824         /*
 825          * Depending on the architecture, allocate some space on the
 826          * user-call-stack based on our expected layout.
 827          */
 828         struct ORANGEFS_dev_map_desc __user *p =
 829             compat_alloc_user_space(sizeof(*p));
 830         compat_uptr_t addr;
 831
 832         *error = 0;
 833         /* get the ptr from the 32 bit user-space */
 834         if (get_user(addr, &p32->ptr))
 835                 goto err;
 836         /* try to put that into a 64-bit layout */
 837         if (put_user(compat_ptr(addr), &p->ptr))
 838                 goto err;
 839         /* copy the remaining fields */
 840         if (copy_in_user(&p->total_size, &p32->total_size, sizeof(__s32)))
 841                 goto err;
 842         if (copy_in_user(&p->size, &p32->size, sizeof(__s32)))
 843                 goto err;
 844         if (copy_in_user(&p->count, &p32->count, sizeof(__s32)))
 845                 goto err;
 846         return (unsigned long)p;
 847 err:
 848         *error = -EFAULT;
 849         return 0;
 850 }
 851
 852 /*
 853  * 32 bit user-space apps' ioctl handlers when kernel modules
 854  * is compiled as a 64 bit one
 855  */
 856 static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
 857                                       unsigned long args)
 858 {
 859         long ret;
 860         unsigned long arg = args;
 861
 862         /* Check for properly constructed commands */
 863         ret = check_ioctl_command(cmd);
 864         if (ret < 0)
 865                 return ret;
 866         if (cmd == ORANGEFS_DEV_MAP) {
 867                 /*
 868                  * convert the arguments to what we expect internally
 869                  * in kernel space
 870                  */
 871                 arg = translate_dev_map26(args, &ret);
 872                 if (ret < 0) {
 873                         gossip_err("Could not translate dev map\n");
 874                         return ret;
 875                 }
 876         }
 877         /* no other ioctl requires translation */
 878         return dispatch_ioctl_command(cmd, arg);
 879 }
 880
 881 #endif /* CONFIG_COMPAT is in .config */
 882
 883 /* the assigned character device major number */
 884 static int orangefs_dev_major;
 885
 886 /*
 887  * Initialize orangefs device specific state:
 888  * Must be called at module load time only
 889  */
 890 int orangefs_dev_init(void)
 891 {
 892         /* register orangefs-req device  */
 893         orangefs_dev_major = register_chrdev(0,
 894                                           ORANGEFS_REQDEVICE_NAME,
 895                                           &orangefs_devreq_file_operations);
 896         if (orangefs_dev_major < 0) {
 897                 gossip_debug(GOSSIP_DEV_DEBUG,
 898                              "Failed to register /dev/%s (error %d)\n",
 899                              ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
 900                 return orangefs_dev_major;
 901         }
 902
 903         gossip_debug(GOSSIP_DEV_DEBUG,
 904                      "*** /dev/%s character device registered ***\n",
 905                      ORANGEFS_REQDEVICE_NAME);
 906         gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n",
 907                      ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
 908         return 0;
 909 }
 910
 911 void orangefs_dev_cleanup(void)
 912 {
 913         unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME);
 914         gossip_debug(GOSSIP_DEV_DEBUG,
 915                      "*** /dev/%s character device unregistered ***\n",
 916                      ORANGEFS_REQDEVICE_NAME);
 917 }
 918
 919 static unsigned int orangefs_devreq_poll(struct file *file,
 920                                       struct poll_table_struct *poll_table)
 921 {
 922         int poll_revent_mask = 0;
 923
 924         poll_wait(file, &orangefs_request_list_waitq, poll_table);
 925
 926         if (!list_empty(&orangefs_request_list))
 927                 poll_revent_mask |= POLL_IN;
 928         return poll_revent_mask;
 929 }
 930
 931 const struct file_operations orangefs_devreq_file_operations = {
 932         .owner = THIS_MODULE,
 933         .read = orangefs_devreq_read,
 934         .write_iter = orangefs_devreq_write_iter,
 935         .open = orangefs_devreq_open,
 936         .release = orangefs_devreq_release,
 937         .unlocked_ioctl = orangefs_devreq_ioctl,
 938
 939 #ifdef CONFIG_COMPAT            /* CONFIG_COMPAT is in .config */
 940         .compat_ioctl = orangefs_devreq_compat_ioctl,
 941 #endif
 942         .poll = orangefs_devreq_poll
 943 };