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

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

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ 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