fs/orangefs/file.c

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