fs/orangefs/file.c

   1 /*
   2  * (C) 2001 Clemson University and The University of Chicago
   3  *
   4  * See COPYING in top-level directory.
   5  */
   6
   7 /*
   8  *  Linux VFS file operations.
   9  */
  10
  11 #include "protocol.h"
  12 #include "orangefs-kernel.h"
  13 #include "orangefs-bufmap.h"
  14 #include <linux/fs.h>
  15 #include <linux/pagemap.h>
  16
  17 #define wake_up_daemon_for_return(op)                   \
  18 do {                                                    \
  19         spin_lock(&op->lock);                           \
  20         op->io_completed = 1;                           \
  21         spin_unlock(&op->lock);                         \
  22         wake_up_interruptible(&op->io_completion_waitq);\
  23 } while (0)
  24
  25 /*
  26  * Copy to client-core's address space from the buffers specified
  27  * by the iovec upto total_size bytes.
  28  * NOTE: the iovector can either contain addresses which
  29  *       can futher be kernel-space or user-space addresses.
  30  *       or it can pointers to struct page's
  31  */
  32 static int precopy_buffers(struct orangefs_bufmap *bufmap,
  33                            int buffer_index,
  34                            struct iov_iter *iter,
  35                            size_t total_size)
  36 {
  37         int ret = 0;
  38         /*
  39          * copy data from application/kernel by pulling it out
  40          * of the iovec.
  41          */
  42
  43
  44         if (total_size) {
  45                 ret = orangefs_bufmap_copy_from_iovec(bufmap,
  46                                                       iter,
  47                                                       buffer_index,
  48                                                       total_size);
  49                 if (ret < 0)
  50                 gossip_err("%s: Failed to copy-in buffers. Please make sure that the pvfs2-client is running. %ld\n",
  51                            __func__,
  52                            (long)ret);
  53         }
  54
  55         if (ret < 0)
  56                 gossip_err("%s: Failed to copy-in buffers. Please make sure that the pvfs2-client is running. %ld\n",
  57                         __func__,
  58                         (long)ret);
  59         return ret;
  60 }
  61
  62 /*
  63  * Copy from client-core's address space to the buffers specified
  64  * by the iovec upto total_size bytes.
  65  * NOTE: the iovector can either contain addresses which
  66  *       can futher be kernel-space or user-space addresses.
  67  *       or it can pointers to struct page's
  68  */
  69 static int postcopy_buffers(struct orangefs_bufmap *bufmap,
  70                             int buffer_index,
  71                             struct iov_iter *iter,
  72                             size_t total_size)
  73 {
  74         int ret = 0;
  75         /*
  76          * copy data to application/kernel by pushing it out to
  77          * the iovec. NOTE; target buffers can be addresses or
  78          * struct page pointers.
  79          */
  80         if (total_size) {
  81                 ret = orangefs_bufmap_copy_to_iovec(bufmap,
  82                                                     iter,
  83                                                     buffer_index,
  84                                                     total_size);
  85                 if (ret < 0)
  86                         gossip_err("%s: Failed to copy-out buffers. Please make sure that the pvfs2-client is running (%ld)\n",
  87                                 __func__,
  88                                 (long)ret);
  89         }
  90         return ret;
  91 }
  92
  93 /*
  94  * Post and wait for the I/O upcall to finish
  95  */
  96 static ssize_t wait_for_direct_io(enum ORANGEFS_io_type type, struct inode *inode,
  97                 loff_t *offset, struct iov_iter *iter,
  98                 size_t total_size, loff_t readahead_size)
  99 {
 100         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 101         struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
 102         struct orangefs_bufmap *bufmap = NULL;
 103         struct orangefs_kernel_op_s *new_op = NULL;
 104         int buffer_index = -1;
 105         ssize_t ret;
 106
 107         new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO);
 108         if (!new_op)
 109                 return -ENOMEM;
 110
 111         /* synchronous I/O */
 112         new_op->upcall.req.io.async_vfs_io = ORANGEFS_VFS_SYNC_IO;
 113         new_op->upcall.req.io.readahead_size = readahead_size;
 114         new_op->upcall.req.io.io_type = type;
 115         new_op->upcall.req.io.refn = orangefs_inode->refn;
 116
 117 populate_shared_memory:
 118         /* get a shared buffer index */
 119         ret = orangefs_bufmap_get(&bufmap, &buffer_index);
 120         if (ret < 0) {
 121                 gossip_debug(GOSSIP_FILE_DEBUG,
 122                              "%s: orangefs_bufmap_get failure (%ld)\n",
 123                              __func__, (long)ret);
 124                 goto out;
 125         }
 126         gossip_debug(GOSSIP_FILE_DEBUG,
 127                      "%s(%pU): GET op %p -> buffer_index %d\n",
 128                      __func__,
 129                      handle,
 130                      new_op,
 131                      buffer_index);
 132
 133         new_op->uses_shared_memory = 1;
 134         new_op->upcall.req.io.buf_index = buffer_index;
 135         new_op->upcall.req.io.count = total_size;
 136         new_op->upcall.req.io.offset = *offset;
 137
 138         gossip_debug(GOSSIP_FILE_DEBUG,
 139                      "%s(%pU): offset: %llu total_size: %zd\n",
 140                      __func__,
 141                      handle,
 142                      llu(*offset),
 143                      total_size);
 144         /*
 145          * Stage 1: copy the buffers into client-core's address space
 146          * precopy_buffers only pertains to writes.
 147          */
 148         if (type == ORANGEFS_IO_WRITE) {
 149                 ret = precopy_buffers(bufmap,
 150                                       buffer_index,
 151                                       iter,
 152                                       total_size);
 153                 if (ret < 0)
 154                         goto out;
 155         }
 156
 157         gossip_debug(GOSSIP_FILE_DEBUG,
 158                      "%s(%pU): Calling post_io_request with tag (%llu)\n",
 159                      __func__,
 160                      handle,
 161                      llu(new_op->tag));
 162
 163         /* Stage 2: Service the I/O operation */
 164         ret = service_operation(new_op,
 165                                 type == ORANGEFS_IO_WRITE ?
 166                                         "file_write" :
 167                                         "file_read",
 168                                 get_interruptible_flag(inode));
 169
 170         /*
 171          * If service_operation() returns -EAGAIN #and# the operation was
 172          * purged from orangefs_request_list or htable_ops_in_progress, then
 173          * we know that the client was restarted, causing the shared memory
 174          * area to be wiped clean.  To restart a  write operation in this
 175          * case, we must re-copy the data from the user's iovec to a NEW
 176          * shared memory location. To restart a read operation, we must get
 177          * a new shared memory location.
 178          */
 179         if (ret == -EAGAIN && op_state_purged(new_op)) {
 180                 orangefs_bufmap_put(bufmap, buffer_index);
 181                 gossip_debug(GOSSIP_FILE_DEBUG,
 182                              "%s:going to repopulate_shared_memory.\n",
 183                              __func__);
 184                 goto populate_shared_memory;
 185         }
 186
 187         if (ret < 0) {
 188                 handle_io_error();
 189                 /*
 190                  * don't write an error to syslog on signaled operation
 191                  * termination unless we've got debugging turned on, as
 192                  * this can happen regularly (i.e. ctrl-c)
 193                  */
 194                 if (ret == -EINTR)
 195                         gossip_debug(GOSSIP_FILE_DEBUG,
 196                                      "%s: returning error %ld\n", __func__,
 197                                      (long)ret);
 198                 else
 199                         gossip_err("%s: error in %s handle %pU, returning %zd\n",
 200                                 __func__,
 201                                 type == ORANGEFS_IO_READ ?
 202                                         "read from" : "write to",
 203                                 handle, ret);
 204                 goto out;
 205         }
 206
 207         /*
 208          * Stage 3: Post copy buffers from client-core's address space
 209          * postcopy_buffers only pertains to reads.
 210          */
 211         if (type == ORANGEFS_IO_READ) {
 212                 ret = postcopy_buffers(bufmap,
 213                                        buffer_index,
 214                                        iter,
 215                                        new_op->downcall.resp.io.amt_complete);
 216                 if (ret < 0) {
 217                         /*
 218                          * put error codes in downcall so that handle_io_error()
 219                          * preserves it properly
 220                          */
 221                         new_op->downcall.status = ret;
 222                         handle_io_error();
 223                         goto out;
 224                 }
 225         }
 226         gossip_debug(GOSSIP_FILE_DEBUG,
 227             "%s(%pU): Amount written as returned by the sys-io call:%d\n",
 228             __func__,
 229             handle,
 230             (int)new_op->downcall.resp.io.amt_complete);
 231
 232         ret = new_op->downcall.resp.io.amt_complete;
 233
 234         /*
 235          * tell the device file owner waiting on I/O that this read has
 236          * completed and it can return now.
 237          */
 238         wake_up_daemon_for_return(new_op);
 239
 240 out:
 241         if (buffer_index >= 0) {
 242                 orangefs_bufmap_put(bufmap, buffer_index);
 243                 gossip_debug(GOSSIP_FILE_DEBUG,
 244                              "%s(%pU): PUT buffer_index %d\n",
 245                              __func__, handle, buffer_index);
 246                 buffer_index = -1;
 247         }
 248         op_release(new_op);
 249         return ret;
 250 }
 251
 252 /*
 253  * Common entry point for read/write/readv/writev
 254  * This function will dispatch it to either the direct I/O
 255  * or buffered I/O path depending on the mount options and/or
 256  * augmented/extended metadata attached to the file.
 257  * Note: File extended attributes override any mount options.
 258  */
 259 static ssize_t do_readv_writev(enum ORANGEFS_io_type type, struct file *file,
 260                 loff_t *offset, struct iov_iter *iter)
 261 {
 262         struct inode *inode = file->f_mapping->host;
 263         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 264         struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
 265         size_t count = iov_iter_count(iter);
 266         ssize_t total_count = 0;
 267         ssize_t ret = -EINVAL;
 268
 269         gossip_debug(GOSSIP_FILE_DEBUG,
 270                 "%s-BEGIN(%pU): count(%d) after estimate_max_iovecs.\n",
 271                 __func__,
 272                 handle,
 273                 (int)count);
 274
 275         if (type == ORANGEFS_IO_WRITE) {
 276                 gossip_debug(GOSSIP_FILE_DEBUG,
 277                              "%s(%pU): proceeding with offset : %llu, "
 278                              "size %d\n",
 279                              __func__,
 280                              handle,
 281                              llu(*offset),
 282                              (int)count);
 283         }
 284
 285         if (count == 0) {
 286                 ret = 0;
 287                 goto out;
 288         }
 289
 290         while (iov_iter_count(iter)) {
 291                 size_t each_count = iov_iter_count(iter);
 292                 size_t amt_complete;
 293
 294                 /* how much to transfer in this loop iteration */
 295                 if (each_count > orangefs_bufmap_size_query())
 296                         each_count = orangefs_bufmap_size_query();
 297
 298                 gossip_debug(GOSSIP_FILE_DEBUG,
 299                              "%s(%pU): size of each_count(%d)\n",
 300                              __func__,
 301                              handle,
 302                              (int)each_count);
 303                 gossip_debug(GOSSIP_FILE_DEBUG,
 304                              "%s(%pU): BEFORE wait_for_io: offset is %d\n",
 305                              __func__,
 306                              handle,
 307                              (int)*offset);
 308
 309                 ret = wait_for_direct_io(type, inode, offset, iter,
 310                                 each_count, 0);
 311                 gossip_debug(GOSSIP_FILE_DEBUG,
 312                              "%s(%pU): return from wait_for_io:%d\n",
 313                              __func__,
 314                              handle,
 315                              (int)ret);
 316
 317                 if (ret < 0)
 318                         goto out;
 319
 320                 *offset += ret;
 321                 total_count += ret;
 322                 amt_complete = ret;
 323
 324                 gossip_debug(GOSSIP_FILE_DEBUG,
 325                              "%s(%pU): AFTER wait_for_io: offset is %d\n",
 326                              __func__,
 327                              handle,
 328                              (int)*offset);
 329
 330                 /*
 331                  * if we got a short I/O operations,
 332                  * fall out and return what we got so far
 333                  */
 334                 if (amt_complete < each_count)
 335                         break;
 336         } /*end while */
 337
 338         if (total_count > 0)
 339                 ret = total_count;
 340 out:
 341         if (ret > 0) {
 342                 if (type == ORANGEFS_IO_READ) {
 343                         file_accessed(file);
 344                 } else {
 345                         SetMtimeFlag(orangefs_inode);
 346                         inode->i_mtime = CURRENT_TIME;
 347                         mark_inode_dirty_sync(inode);
 348                 }
 349         }
 350
 351         gossip_debug(GOSSIP_FILE_DEBUG,
 352                      "%s(%pU): Value(%d) returned.\n",
 353                      __func__,
 354                      handle,
 355                      (int)ret);
 356
 357         return ret;
 358 }
 359
 360 /*
 361  * Read data from a specified offset in a file (referenced by inode).
 362  * Data may be placed either in a user or kernel buffer.
 363  */
 364 ssize_t orangefs_inode_read(struct inode *inode,
 365                             struct iov_iter *iter,
 366                             loff_t *offset,
 367                             loff_t readahead_size)
 368 {
 369         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 370         size_t count = iov_iter_count(iter);
 371         size_t bufmap_size;
 372         ssize_t ret = -EINVAL;
 373
 374         g_orangefs_stats.reads++;
 375
 376         bufmap_size = orangefs_bufmap_size_query();
 377         if (count > bufmap_size) {
 378                 gossip_debug(GOSSIP_FILE_DEBUG,
 379                              "%s: count is too large (%zd/%zd)!\n",
 380                              __func__, count, bufmap_size);
 381                 return -EINVAL;
 382         }
 383
 384         gossip_debug(GOSSIP_FILE_DEBUG,
 385                      "%s(%pU) %zd@%llu\n",
 386                      __func__,
 387                      &orangefs_inode->refn.khandle,
 388                      count,
 389                      llu(*offset));
 390
 391         ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, offset, iter,
 392                         count, readahead_size);
 393         if (ret > 0)
 394                 *offset += ret;
 395
 396         gossip_debug(GOSSIP_FILE_DEBUG,
 397                      "%s(%pU): Value(%zd) returned.\n",
 398                      __func__,
 399                      &orangefs_inode->refn.khandle,
 400                      ret);
 401
 402         return ret;
 403 }
 404
 405 static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 406 {
 407         struct file *file = iocb->ki_filp;
 408         loff_t pos = *(&iocb->ki_pos);
 409         ssize_t rc = 0;
 410
 411         BUG_ON(iocb->private);
 412
 413         gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n");
 414
 415         g_orangefs_stats.reads++;
 416
 417         rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter);
 418         iocb->ki_pos = pos;
 419
 420         return rc;
 421 }
 422
 423 static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
 424 {
 425         struct file *file = iocb->ki_filp;
 426         loff_t pos;
 427         ssize_t rc;
 428
 429         BUG_ON(iocb->private);
 430
 431         gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_write_iter\n");
 432
 433         mutex_lock(&file->f_mapping->host->i_mutex);
 434
 435         /* Make sure generic_write_checks sees an up to date inode size. */
 436         if (file->f_flags & O_APPEND) {
 437                 rc = orangefs_inode_getattr(file->f_mapping->host,
 438                                          ORANGEFS_ATTR_SYS_SIZE);
 439                 if (rc) {
 440                         gossip_err("%s: orangefs_inode_getattr failed, rc:%zd:.\n",
 441                                    __func__, rc);
 442                         goto out;
 443                 }
 444         }
 445
 446         if (file->f_pos > i_size_read(file->f_mapping->host))
 447                 orangefs_i_size_write(file->f_mapping->host, file->f_pos);
 448
 449         rc = generic_write_checks(iocb, iter);
 450
 451         if (rc <= 0) {
 452                 gossip_err("%s: generic_write_checks failed, rc:%zd:.\n",
 453                            __func__, rc);
 454                 goto out;
 455         }
 456
 457         /*
 458          * if we are appending, generic_write_checks would have updated
 459          * pos to the end of the file, so we will wait till now to set
 460          * pos...
 461          */
 462         pos = *(&iocb->ki_pos);
 463
 464         rc = do_readv_writev(ORANGEFS_IO_WRITE,
 465                              file,
 466                              &pos,
 467                              iter);
 468         if (rc < 0) {
 469                 gossip_err("%s: do_readv_writev failed, rc:%zd:.\n",
 470                            __func__, rc);
 471                 goto out;
 472         }
 473
 474         iocb->ki_pos = pos;
 475         g_orangefs_stats.writes++;
 476
 477 out:
 478
 479         mutex_unlock(&file->f_mapping->host->i_mutex);
 480         return rc;
 481 }
 482
 483 /*
 484  * Perform a miscellaneous operation on a file.
 485  */
 486 static long orangefs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 487 {
 488         int ret = -ENOTTY;
 489         __u64 val = 0;
 490         unsigned long uval;
 491
 492         gossip_debug(GOSSIP_FILE_DEBUG,
 493                      "orangefs_ioctl: called with cmd %d\n",
 494                      cmd);
 495
 496         /*
 497          * we understand some general ioctls on files, such as the immutable
 498          * and append flags
 499          */
 500         if (cmd == FS_IOC_GETFLAGS) {
 501                 val = 0;
 502                 ret = orangefs_inode_getxattr(file_inode(file),
 503                                               ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
 504                                               "user.pvfs2.meta_hint",
 505                                               &val, sizeof(val));
 506                 if (ret < 0 && ret != -ENODATA)
 507                         return ret;
 508                 else if (ret == -ENODATA)
 509                         val = 0;
 510                 uval = val;
 511                 gossip_debug(GOSSIP_FILE_DEBUG,
 512                              "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n",
 513                              (unsigned long long)uval);
 514                 return put_user(uval, (int __user *)arg);
 515         } else if (cmd == FS_IOC_SETFLAGS) {
 516                 ret = 0;
 517                 if (get_user(uval, (int __user *)arg))
 518                         return -EFAULT;
 519                 /*
 520                  * ORANGEFS_MIRROR_FL is set internally when the mirroring mode
 521                  * is turned on for a file. The user is not allowed to turn
 522                  * on this bit, but the bit is present if the user first gets
 523                  * the flags and then updates the flags with some new
 524                  * settings. So, we ignore it in the following edit. bligon.
 525                  */
 526                 if ((uval & ~ORANGEFS_MIRROR_FL) &
 527                     (~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) {
 528                         gossip_err("orangefs_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n");
 529                         return -EINVAL;
 530                 }
 531                 val = uval;
 532                 gossip_debug(GOSSIP_FILE_DEBUG,
 533                              "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n",
 534                              (unsigned long long)val);
 535                 ret = orangefs_inode_setxattr(file_inode(file),
 536                                               ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
 537                                               "user.pvfs2.meta_hint",
 538                                               &val, sizeof(val), 0);
 539         }
 540
 541         return ret;
 542 }
 543
 544 /*
 545  * Memory map a region of a file.
 546  */
 547 static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma)
 548 {
 549         gossip_debug(GOSSIP_FILE_DEBUG,
 550                      "orangefs_file_mmap: called on %s\n",
 551                      (file ?
 552                         (char *)file->f_path.dentry->d_name.name :
 553                         (char *)"Unknown"));
 554
 555         /* set the sequential readahead hint */
 556         vma->vm_flags |= VM_SEQ_READ;
 557         vma->vm_flags &= ~VM_RAND_READ;
 558
 559         /* Use readonly mmap since we cannot support writable maps. */
 560         return generic_file_readonly_mmap(file, vma);
 561 }
 562
 563 #define mapping_nrpages(idata) ((idata)->nrpages)
 564
 565 /*
 566  * Called to notify the module that there are no more references to
 567  * this file (i.e. no processes have it open).
 568  *
 569  * \note Not called when each file is closed.
 570  */
 571 static int orangefs_file_release(struct inode *inode, struct file *file)
 572 {
 573         gossip_debug(GOSSIP_FILE_DEBUG,
 574                      "orangefs_file_release: called on %s\n",
 575                      file->f_path.dentry->d_name.name);
 576
 577         orangefs_flush_inode(inode);
 578
 579         /*
 580          * remove all associated inode pages from the page cache and mmap
 581          * readahead cache (if any); this forces an expensive refresh of
 582          * data for the next caller of mmap (or 'get_block' accesses)
 583          */
 584         if (file->f_path.dentry->d_inode &&
 585             file->f_path.dentry->d_inode->i_mapping &&
 586             mapping_nrpages(&file->f_path.dentry->d_inode->i_data))
 587                 truncate_inode_pages(file->f_path.dentry->d_inode->i_mapping,
 588                                      0);
 589         return 0;
 590 }
 591
 592 /*
 593  * Push all data for a specific file onto permanent storage.
 594  */
 595 static int orangefs_fsync(struct file *file,
 596                        loff_t start,
 597                        loff_t end,
 598                        int datasync)
 599 {
 600         int ret = -EINVAL;
 601         struct orangefs_inode_s *orangefs_inode =
 602                 ORANGEFS_I(file->f_path.dentry->d_inode);
 603         struct orangefs_kernel_op_s *new_op = NULL;
 604
 605         /* required call */
 606         filemap_write_and_wait_range(file->f_mapping, start, end);
 607
 608         new_op = op_alloc(ORANGEFS_VFS_OP_FSYNC);
 609         if (!new_op)
 610                 return -ENOMEM;
 611         new_op->upcall.req.fsync.refn = orangefs_inode->refn;
 612
 613         ret = service_operation(new_op,
 614                         "orangefs_fsync",
 615                         get_interruptible_flag(file->f_path.dentry->d_inode));
 616
 617         gossip_debug(GOSSIP_FILE_DEBUG,
 618                      "orangefs_fsync got return value of %d\n",
 619                      ret);
 620
 621         op_release(new_op);
 622
 623         orangefs_flush_inode(file->f_path.dentry->d_inode);
 624         return ret;
 625 }
 626
 627 /*
 628  * Change the file pointer position for an instance of an open file.
 629  *
 630  * \note If .llseek is overriden, we must acquire lock as described in
 631  *       Documentation/filesystems/Locking.
 632  *
 633  * Future upgrade could support SEEK_DATA and SEEK_HOLE but would
 634  * require much changes to the FS
 635  */
 636 static loff_t orangefs_file_llseek(struct file *file, loff_t offset, int origin)
 637 {
 638         int ret = -EINVAL;
 639         struct inode *inode = file->f_path.dentry->d_inode;
 640
 641         if (!inode) {
 642                 gossip_err("orangefs_file_llseek: invalid inode (NULL)\n");
 643                 return ret;
 644         }
 645
 646         if (origin == ORANGEFS_SEEK_END) {
 647                 /*
 648                  * revalidate the inode's file size.
 649                  * NOTE: We are only interested in file size here,
 650                  * so we set mask accordingly.
 651                  */
 652                 ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_SIZE);
 653                 if (ret) {
 654                         gossip_debug(GOSSIP_FILE_DEBUG,
 655                                      "%s:%s:%d calling make bad inode\n",
 656                                      __FILE__,
 657                                      __func__,
 658                                      __LINE__);
 659                         orangefs_make_bad_inode(inode);
 660                         return ret;
 661                 }
 662         }
 663
 664         gossip_debug(GOSSIP_FILE_DEBUG,
 665                      "orangefs_file_llseek: offset is %ld | origin is %d"
 666                      " | inode size is %lu\n",
 667                      (long)offset,
 668                      origin,
 669                      (unsigned long)file->f_path.dentry->d_inode->i_size);
 670
 671         return generic_file_llseek(file, offset, origin);
 672 }
 673
 674 /*
 675  * Support local locks (locks that only this kernel knows about)
 676  * if Orangefs was mounted -o local_lock.
 677  */
 678 static int orangefs_lock(struct file *filp, int cmd, struct file_lock *fl)
 679 {
 680         int rc = -EINVAL;
 681
 682         if (ORANGEFS_SB(filp->f_inode->i_sb)->flags & ORANGEFS_OPT_LOCAL_LOCK) {
 683                 if (cmd == F_GETLK) {
 684                         rc = 0;
 685                         posix_test_lock(filp, fl);
 686                 } else {
 687                         rc = posix_lock_file(filp, fl, NULL);
 688                 }
 689         }
 690
 691         return rc;
 692 }
 693
 694 /** ORANGEFS implementation of VFS file operations */
 695 const struct file_operations orangefs_file_operations = {
 696         .llseek         = orangefs_file_llseek,
 697         .read_iter      = orangefs_file_read_iter,
 698         .write_iter     = orangefs_file_write_iter,
 699         .lock           = orangefs_lock,
 700         .unlocked_ioctl = orangefs_ioctl,
 701         .mmap           = orangefs_file_mmap,
 702         .open           = generic_file_open,
 703         .release        = orangefs_file_release,
 704         .fsync          = orangefs_fsync,
 705 };