~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/orangefs/file.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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         rc = generic_write_checks(iocb, iter);
496 
497         if (rc <= 0) {
498                 gossip_err("%s: generic_write_checks failed, rc:%zd:.\n",
499                            __func__, rc);
500                 goto out;
501         }
502 
503         /*
504          * if we are appending, generic_write_checks would have updated
505          * pos to the end of the file, so we will wait till now to set
506          * pos...
507          */
508         pos = iocb->ki_pos;
509 
510         rc = do_readv_writev(ORANGEFS_IO_WRITE,
511                              file,
512                              &pos,
513                              iter);
514         if (rc < 0) {
515                 gossip_err("%s: do_readv_writev failed, rc:%zd:.\n",
516                            __func__, rc);
517                 goto out;
518         }
519 
520         iocb->ki_pos = pos;
521         orangefs_stats.writes++;
522 
523 out:
524 
525         inode_unlock(file->f_mapping->host);
526         return rc;
527 }
528 
529 /*
530  * Perform a miscellaneous operation on a file.
531  */
532 static long orangefs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
533 {
534         int ret = -ENOTTY;
535         __u64 val = 0;
536         unsigned long uval;
537 
538         gossip_debug(GOSSIP_FILE_DEBUG,
539                      "orangefs_ioctl: called with cmd %d\n",
540                      cmd);
541 
542         /*
543          * we understand some general ioctls on files, such as the immutable
544          * and append flags
545          */
546         if (cmd == FS_IOC_GETFLAGS) {
547                 val = 0;
548                 ret = orangefs_inode_getxattr(file_inode(file),
549                                               "user.pvfs2.meta_hint",
550                                               &val, sizeof(val));
551                 if (ret < 0 && ret != -ENODATA)
552                         return ret;
553                 else if (ret == -ENODATA)
554                         val = 0;
555                 uval = val;
556                 gossip_debug(GOSSIP_FILE_DEBUG,
557                              "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n",
558                              (unsigned long long)uval);
559                 return put_user(uval, (int __user *)arg);
560         } else if (cmd == FS_IOC_SETFLAGS) {
561                 ret = 0;
562                 if (get_user(uval, (int __user *)arg))
563                         return -EFAULT;
564                 /*
565                  * ORANGEFS_MIRROR_FL is set internally when the mirroring mode
566                  * is turned on for a file. The user is not allowed to turn
567                  * on this bit, but the bit is present if the user first gets
568                  * the flags and then updates the flags with some new
569                  * settings. So, we ignore it in the following edit. bligon.
570                  */
571                 if ((uval & ~ORANGEFS_MIRROR_FL) &
572                     (~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) {
573                         gossip_err("orangefs_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n");
574                         return -EINVAL;
575                 }
576                 val = uval;
577                 gossip_debug(GOSSIP_FILE_DEBUG,
578                              "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n",
579                              (unsigned long long)val);
580                 ret = orangefs_inode_setxattr(file_inode(file),
581                                               "user.pvfs2.meta_hint",
582                                               &val, sizeof(val), 0);
583         }
584 
585         return ret;
586 }
587 
588 /*
589  * Memory map a region of a file.
590  */
591 static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma)
592 {
593         gossip_debug(GOSSIP_FILE_DEBUG,
594                      "orangefs_file_mmap: called on %s\n",
595                      (file ?
596                         (char *)file->f_path.dentry->d_name.name :
597                         (char *)"Unknown"));
598 
599         /* set the sequential readahead hint */
600         vma->vm_flags |= VM_SEQ_READ;
601         vma->vm_flags &= ~VM_RAND_READ;
602 
603         /* Use readonly mmap since we cannot support writable maps. */
604         return generic_file_readonly_mmap(file, vma);
605 }
606 
607 #define mapping_nrpages(idata) ((idata)->nrpages)
608 
609 /*
610  * Called to notify the module that there are no more references to
611  * this file (i.e. no processes have it open).
612  *
613  * \note Not called when each file is closed.
614  */
615 static int orangefs_file_release(struct inode *inode, struct file *file)
616 {
617         gossip_debug(GOSSIP_FILE_DEBUG,
618                      "orangefs_file_release: called on %pD\n",
619                      file);
620 
621         /*
622          * remove all associated inode pages from the page cache and
623          * readahead cache (if any); this forces an expensive refresh of
624          * data for the next caller of mmap (or 'get_block' accesses)
625          */
626         if (file_inode(file) &&
627             file_inode(file)->i_mapping &&
628             mapping_nrpages(&file_inode(file)->i_data)) {
629                 if (orangefs_features & ORANGEFS_FEATURE_READAHEAD) {
630                         gossip_debug(GOSSIP_INODE_DEBUG,
631                             "calling flush_racache on %pU\n",
632                             get_khandle_from_ino(inode));
633                         flush_racache(inode);
634                         gossip_debug(GOSSIP_INODE_DEBUG,
635                             "flush_racache finished\n");
636                 }
637                 truncate_inode_pages(file_inode(file)->i_mapping,
638                                      0);
639         }
640         return 0;
641 }
642 
643 /*
644  * Push all data for a specific file onto permanent storage.
645  */
646 static int orangefs_fsync(struct file *file,
647                        loff_t start,
648                        loff_t end,
649                        int datasync)
650 {
651         int ret;
652         struct orangefs_inode_s *orangefs_inode =
653                 ORANGEFS_I(file_inode(file));
654         struct orangefs_kernel_op_s *new_op = NULL;
655 
656         new_op = op_alloc(ORANGEFS_VFS_OP_FSYNC);
657         if (!new_op)
658                 return -ENOMEM;
659         new_op->upcall.req.fsync.refn = orangefs_inode->refn;
660 
661         ret = service_operation(new_op,
662                         "orangefs_fsync",
663                         get_interruptible_flag(file_inode(file)));
664 
665         gossip_debug(GOSSIP_FILE_DEBUG,
666                      "orangefs_fsync got return value of %d\n",
667                      ret);
668 
669         op_release(new_op);
670         return ret;
671 }
672 
673 /*
674  * Change the file pointer position for an instance of an open file.
675  *
676  * \note If .llseek is overriden, we must acquire lock as described in
677  *       Documentation/filesystems/Locking.
678  *
679  * Future upgrade could support SEEK_DATA and SEEK_HOLE but would
680  * require much changes to the FS
681  */
682 static loff_t orangefs_file_llseek(struct file *file, loff_t offset, int origin)
683 {
684         int ret = -EINVAL;
685         struct inode *inode = file_inode(file);
686 
687         if (origin == SEEK_END) {
688                 /*
689                  * revalidate the inode's file size.
690                  * NOTE: We are only interested in file size here,
691                  * so we set mask accordingly.
692                  */
693                 ret = orangefs_inode_getattr(file->f_mapping->host, 0, 1,
694                     STATX_SIZE);
695                 if (ret == -ESTALE)
696                         ret = -EIO;
697                 if (ret) {
698                         gossip_debug(GOSSIP_FILE_DEBUG,
699                                      "%s:%s:%d calling make bad inode\n",
700                                      __FILE__,
701                                      __func__,
702                                      __LINE__);
703                         return ret;
704                 }
705         }
706 
707         gossip_debug(GOSSIP_FILE_DEBUG,
708                      "orangefs_file_llseek: offset is %ld | origin is %d"
709                      " | inode size is %lu\n",
710                      (long)offset,
711                      origin,
712                      (unsigned long)i_size_read(inode));
713 
714         return generic_file_llseek(file, offset, origin);
715 }
716 
717 /*
718  * Support local locks (locks that only this kernel knows about)
719  * if Orangefs was mounted -o local_lock.
720  */
721 static int orangefs_lock(struct file *filp, int cmd, struct file_lock *fl)
722 {
723         int rc = -EINVAL;
724 
725         if (ORANGEFS_SB(file_inode(filp)->i_sb)->flags & ORANGEFS_OPT_LOCAL_LOCK) {
726                 if (cmd == F_GETLK) {
727                         rc = 0;
728                         posix_test_lock(filp, fl);
729                 } else {
730                         rc = posix_lock_file(filp, fl, NULL);
731                 }
732         }
733 
734         return rc;
735 }
736 
737 /** ORANGEFS implementation of VFS file operations */
738 const struct file_operations orangefs_file_operations = {
739         .llseek         = orangefs_file_llseek,
740         .read_iter      = orangefs_file_read_iter,
741         .write_iter     = orangefs_file_write_iter,
742         .lock           = orangefs_lock,
743         .unlocked_ioctl = orangefs_ioctl,
744         .mmap           = orangefs_file_mmap,
745         .open           = generic_file_open,
746         .release        = orangefs_file_release,
747         .fsync          = orangefs_fsync,
748 };
749 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp