1 // SPDX-License-Identifier: GPL-2.0
3 * (C) 2001 Clemson University and The University of Chicago
5 * See COPYING in top-level directory.
9 * Linux VFS file operations.
13 #include "orangefs-kernel.h"
14 #include "orangefs-bufmap.h"
16 #include <linux/pagemap.h>
18 static int flush_racache(struct inode *inode)
20 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
21 struct orangefs_kernel_op_s *new_op;
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);
29 new_op = op_alloc(ORANGEFS_VFS_OP_RA_FLUSH);
32 new_op->upcall.req.ra_cache_flush.refn = orangefs_inode->refn;
34 ret = service_operation(new_op, "orangefs_flush_racache",
35 get_interruptible_flag(inode));
37 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: got return value of %d\n",
45 * Post and wait for the I/O upcall to finish
47 static ssize_t wait_for_direct_io(enum ORANGEFS_io_type type, struct inode *inode,
48 loff_t *offset, struct iov_iter *iter,
49 size_t total_size, loff_t readahead_size)
51 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
52 struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
53 struct orangefs_kernel_op_s *new_op = NULL;
54 int buffer_index = -1;
57 new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO);
62 new_op->upcall.req.io.readahead_size = readahead_size;
63 new_op->upcall.req.io.io_type = type;
64 new_op->upcall.req.io.refn = orangefs_inode->refn;
66 populate_shared_memory:
67 /* get a shared buffer index */
68 buffer_index = orangefs_bufmap_get();
69 if (buffer_index < 0) {
71 gossip_debug(GOSSIP_FILE_DEBUG,
72 "%s: orangefs_bufmap_get failure (%zd)\n",
76 gossip_debug(GOSSIP_FILE_DEBUG,
77 "%s(%pU): GET op %p -> buffer_index %d\n",
83 new_op->uses_shared_memory = 1;
84 new_op->upcall.req.io.buf_index = buffer_index;
85 new_op->upcall.req.io.count = total_size;
86 new_op->upcall.req.io.offset = *offset;
88 gossip_debug(GOSSIP_FILE_DEBUG,
89 "%s(%pU): offset: %llu total_size: %zd\n",
95 * Stage 1: copy the buffers into client-core's address space
97 if (type == ORANGEFS_IO_WRITE && total_size) {
98 ret = orangefs_bufmap_copy_from_iovec(iter, buffer_index,
101 gossip_err("%s: Failed to copy-in buffers. Please make sure that the pvfs2-client is running. %ld\n",
102 __func__, (long)ret);
107 gossip_debug(GOSSIP_FILE_DEBUG,
108 "%s(%pU): Calling post_io_request with tag (%llu)\n",
113 /* Stage 2: Service the I/O operation */
114 ret = service_operation(new_op,
115 type == ORANGEFS_IO_WRITE ?
118 get_interruptible_flag(inode));
121 * If service_operation() returns -EAGAIN #and# the operation was
122 * purged from orangefs_request_list or htable_ops_in_progress, then
123 * we know that the client was restarted, causing the shared memory
124 * area to be wiped clean. To restart a write operation in this
125 * case, we must re-copy the data from the user's iovec to a NEW
126 * shared memory location. To restart a read operation, we must get
127 * a new shared memory location.
129 if (ret == -EAGAIN && op_state_purged(new_op)) {
130 orangefs_bufmap_put(buffer_index);
132 if (type == ORANGEFS_IO_WRITE)
133 iov_iter_revert(iter, total_size);
134 gossip_debug(GOSSIP_FILE_DEBUG,
135 "%s:going to repopulate_shared_memory.\n",
137 goto populate_shared_memory;
143 * We can't return EINTR if any data was written,
144 * it's not POSIX. It is minimally acceptable
145 * to give a partial write, the way NFS does.
147 * It would be optimal to return all or nothing,
148 * but if a userspace write is bigger than
149 * an IO buffer, and the interrupt occurs
150 * between buffer writes, that would not be
153 switch (new_op->op_state - OP_VFS_STATE_GIVEN_UP) {
155 * If the op was waiting when the interrupt
156 * occurred, then the client-core did not
159 case OP_VFS_STATE_WAITING:
166 * If the op was in progress when the interrupt
167 * occurred, then the client-core was able to
170 case OP_VFS_STATE_INPROGR:
174 gossip_err("%s: unexpected op state :%d:.\n",
180 gossip_debug(GOSSIP_FILE_DEBUG,
181 "%s: got EINTR, state:%d: %p\n",
186 gossip_err("%s: error in %s handle %pU, returning %zd\n",
188 type == ORANGEFS_IO_READ ?
189 "read from" : "write to",
192 if (orangefs_cancel_op_in_progress(new_op))
199 * Stage 3: Post copy buffers from client-core's address space
201 if (type == ORANGEFS_IO_READ && new_op->downcall.resp.io.amt_complete) {
203 * NOTE: the iovector can either contain addresses which
204 * can futher be kernel-space or user-space addresses.
205 * or it can pointers to struct page's
207 ret = orangefs_bufmap_copy_to_iovec(iter, buffer_index,
208 new_op->downcall.resp.io.amt_complete);
210 gossip_err("%s: Failed to copy-out buffers. Please make sure that the pvfs2-client is running (%ld)\n",
211 __func__, (long)ret);
215 gossip_debug(GOSSIP_FILE_DEBUG,
216 "%s(%pU): Amount %s, returned by the sys-io call:%d\n",
219 type == ORANGEFS_IO_READ ? "read" : "written",
220 (int)new_op->downcall.resp.io.amt_complete);
222 ret = new_op->downcall.resp.io.amt_complete;
225 if (buffer_index >= 0) {
226 orangefs_bufmap_put(buffer_index);
227 gossip_debug(GOSSIP_FILE_DEBUG,
228 "%s(%pU): PUT buffer_index %d\n",
229 __func__, handle, buffer_index);
237 * Common entry point for read/write/readv/writev
238 * This function will dispatch it to either the direct I/O
239 * or buffered I/O path depending on the mount options and/or
240 * augmented/extended metadata attached to the file.
241 * Note: File extended attributes override any mount options.
243 static ssize_t do_readv_writev(enum ORANGEFS_io_type type, struct file *file,
244 loff_t *offset, struct iov_iter *iter)
246 struct inode *inode = file->f_mapping->host;
247 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
248 struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
249 size_t count = iov_iter_count(iter);
250 ssize_t total_count = 0;
251 ssize_t ret = -EINVAL;
253 gossip_debug(GOSSIP_FILE_DEBUG,
254 "%s-BEGIN(%pU): count(%d) after estimate_max_iovecs.\n",
259 if (type == ORANGEFS_IO_WRITE) {
260 gossip_debug(GOSSIP_FILE_DEBUG,
261 "%s(%pU): proceeding with offset : %llu, "
274 while (iov_iter_count(iter)) {
275 size_t each_count = iov_iter_count(iter);
278 /* how much to transfer in this loop iteration */
279 if (each_count > orangefs_bufmap_size_query())
280 each_count = orangefs_bufmap_size_query();
282 gossip_debug(GOSSIP_FILE_DEBUG,
283 "%s(%pU): size of each_count(%d)\n",
287 gossip_debug(GOSSIP_FILE_DEBUG,
288 "%s(%pU): BEFORE wait_for_io: offset is %d\n",
293 ret = wait_for_direct_io(type, inode, offset, iter,
295 gossip_debug(GOSSIP_FILE_DEBUG,
296 "%s(%pU): return from wait_for_io:%d\n",
308 gossip_debug(GOSSIP_FILE_DEBUG,
309 "%s(%pU): AFTER wait_for_io: offset is %d\n",
315 * if we got a short I/O operations,
316 * fall out and return what we got so far
318 if (amt_complete < each_count)
326 if (type == ORANGEFS_IO_READ) {
329 file_update_time(file);
331 * Must invalidate to ensure write loop doesn't
332 * prevent kernel from reading updated
333 * attribute. Size probably changed because of
334 * the write, and other clients could update
335 * any other attribute.
337 orangefs_inode->getattr_time = jiffies - 1;
341 gossip_debug(GOSSIP_FILE_DEBUG,
342 "%s(%pU): Value(%d) returned.\n",
351 * Read data from a specified offset in a file (referenced by inode).
352 * Data may be placed either in a user or kernel buffer.
354 ssize_t orangefs_inode_read(struct inode *inode,
355 struct iov_iter *iter,
357 loff_t readahead_size)
359 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
360 size_t count = iov_iter_count(iter);
362 ssize_t ret = -EINVAL;
364 orangefs_stats.reads++;
366 bufmap_size = orangefs_bufmap_size_query();
367 if (count > bufmap_size) {
368 gossip_debug(GOSSIP_FILE_DEBUG,
369 "%s: count is too large (%zd/%zd)!\n",
370 __func__, count, bufmap_size);
374 gossip_debug(GOSSIP_FILE_DEBUG,
375 "%s(%pU) %zd@%llu\n",
377 &orangefs_inode->refn.khandle,
381 ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, offset, iter,
382 count, readahead_size);
386 gossip_debug(GOSSIP_FILE_DEBUG,
387 "%s(%pU): Value(%zd) returned.\n",
389 &orangefs_inode->refn.khandle,
395 static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
397 struct file *file = iocb->ki_filp;
398 loff_t pos = iocb->ki_pos;
401 gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n");
403 orangefs_stats.reads++;
405 rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter);
411 static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
413 struct file *file = iocb->ki_filp;
417 gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_write_iter\n");
419 inode_lock(file->f_mapping->host);
421 /* Make sure generic_write_checks sees an up to date inode size. */
422 if (file->f_flags & O_APPEND) {
423 rc = orangefs_inode_getattr(file->f_mapping->host, 0, 1,
428 gossip_err("%s: orangefs_inode_getattr failed, "
429 "rc:%zd:.\n", __func__, rc);
434 rc = generic_write_checks(iocb, iter);
437 gossip_err("%s: generic_write_checks failed, rc:%zd:.\n",
443 * if we are appending, generic_write_checks would have updated
444 * pos to the end of the file, so we will wait till now to set
449 rc = do_readv_writev(ORANGEFS_IO_WRITE,
454 gossip_err("%s: do_readv_writev failed, rc:%zd:.\n",
460 orangefs_stats.writes++;
464 inode_unlock(file->f_mapping->host);
469 * Perform a miscellaneous operation on a file.
471 static long orangefs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
477 gossip_debug(GOSSIP_FILE_DEBUG,
478 "orangefs_ioctl: called with cmd %d\n",
482 * we understand some general ioctls on files, such as the immutable
485 if (cmd == FS_IOC_GETFLAGS) {
487 ret = orangefs_inode_getxattr(file_inode(file),
488 "user.pvfs2.meta_hint",
490 if (ret < 0 && ret != -ENODATA)
492 else if (ret == -ENODATA)
495 gossip_debug(GOSSIP_FILE_DEBUG,
496 "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n",
497 (unsigned long long)uval);
498 return put_user(uval, (int __user *)arg);
499 } else if (cmd == FS_IOC_SETFLAGS) {
501 if (get_user(uval, (int __user *)arg))
504 * ORANGEFS_MIRROR_FL is set internally when the mirroring mode
505 * is turned on for a file. The user is not allowed to turn
506 * on this bit, but the bit is present if the user first gets
507 * the flags and then updates the flags with some new
508 * settings. So, we ignore it in the following edit. bligon.
510 if ((uval & ~ORANGEFS_MIRROR_FL) &
511 (~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) {
512 gossip_err("orangefs_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n");
516 gossip_debug(GOSSIP_FILE_DEBUG,
517 "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n",
518 (unsigned long long)val);
519 ret = orangefs_inode_setxattr(file_inode(file),
520 "user.pvfs2.meta_hint",
521 &val, sizeof(val), 0);
527 static vm_fault_t orangefs_fault(struct vm_fault *vmf)
529 struct file *file = vmf->vma->vm_file;
532 ret = orangefs_inode_getattr(file->f_mapping->host, 0, 1,
537 gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
539 return VM_FAULT_SIGBUS;
541 return filemap_fault(vmf);
544 static const struct vm_operations_struct orangefs_file_vm_ops = {
545 .fault = orangefs_fault,
546 .map_pages = filemap_map_pages,
547 .page_mkwrite = filemap_page_mkwrite,
551 * Memory map a region of a file.
553 static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma)
555 gossip_debug(GOSSIP_FILE_DEBUG,
556 "orangefs_file_mmap: called on %s\n",
558 (char *)file->f_path.dentry->d_name.name :
561 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE))
564 /* set the sequential readahead hint */
565 vma->vm_flags |= VM_SEQ_READ;
566 vma->vm_flags &= ~VM_RAND_READ;
569 vma->vm_ops = &orangefs_file_vm_ops;
573 #define mapping_nrpages(idata) ((idata)->nrpages)
576 * Called to notify the module that there are no more references to
577 * this file (i.e. no processes have it open).
579 * \note Not called when each file is closed.
581 static int orangefs_file_release(struct inode *inode, struct file *file)
583 gossip_debug(GOSSIP_FILE_DEBUG,
584 "orangefs_file_release: called on %pD\n",
588 * remove all associated inode pages from the page cache and
589 * readahead cache (if any); this forces an expensive refresh of
590 * data for the next caller of mmap (or 'get_block' accesses)
592 if (file_inode(file) &&
593 file_inode(file)->i_mapping &&
594 mapping_nrpages(&file_inode(file)->i_data)) {
595 if (orangefs_features & ORANGEFS_FEATURE_READAHEAD) {
596 gossip_debug(GOSSIP_INODE_DEBUG,
597 "calling flush_racache on %pU\n",
598 get_khandle_from_ino(inode));
599 flush_racache(inode);
600 gossip_debug(GOSSIP_INODE_DEBUG,
601 "flush_racache finished\n");
603 truncate_inode_pages(file_inode(file)->i_mapping,
610 * Push all data for a specific file onto permanent storage.
612 static int orangefs_fsync(struct file *file,
618 struct orangefs_inode_s *orangefs_inode =
619 ORANGEFS_I(file_inode(file));
620 struct orangefs_kernel_op_s *new_op = NULL;
622 new_op = op_alloc(ORANGEFS_VFS_OP_FSYNC);
625 new_op->upcall.req.fsync.refn = orangefs_inode->refn;
627 ret = service_operation(new_op,
629 get_interruptible_flag(file_inode(file)));
631 gossip_debug(GOSSIP_FILE_DEBUG,
632 "orangefs_fsync got return value of %d\n",
640 * Change the file pointer position for an instance of an open file.
642 * \note If .llseek is overriden, we must acquire lock as described in
643 * Documentation/filesystems/Locking.
645 * Future upgrade could support SEEK_DATA and SEEK_HOLE but would
646 * require much changes to the FS
648 static loff_t orangefs_file_llseek(struct file *file, loff_t offset, int origin)
651 struct inode *inode = file_inode(file);
653 if (origin == SEEK_END) {
655 * revalidate the inode's file size.
656 * NOTE: We are only interested in file size here,
657 * so we set mask accordingly.
659 ret = orangefs_inode_getattr(file->f_mapping->host, 0, 1,
664 gossip_debug(GOSSIP_FILE_DEBUG,
665 "%s:%s:%d calling make bad inode\n",
673 gossip_debug(GOSSIP_FILE_DEBUG,
674 "orangefs_file_llseek: offset is %ld | origin is %d"
675 " | inode size is %lu\n",
678 (unsigned long)i_size_read(inode));
680 return generic_file_llseek(file, offset, origin);
684 * Support local locks (locks that only this kernel knows about)
685 * if Orangefs was mounted -o local_lock.
687 static int orangefs_lock(struct file *filp, int cmd, struct file_lock *fl)
691 if (ORANGEFS_SB(file_inode(filp)->i_sb)->flags & ORANGEFS_OPT_LOCAL_LOCK) {
692 if (cmd == F_GETLK) {
694 posix_test_lock(filp, fl);
696 rc = posix_lock_file(filp, fl, NULL);
703 /** ORANGEFS implementation of VFS file operations */
704 const struct file_operations orangefs_file_operations = {
705 .llseek = orangefs_file_llseek,
706 .read_iter = orangefs_file_read_iter,
707 .write_iter = orangefs_file_write_iter,
708 .lock = orangefs_lock,
709 .unlocked_ioctl = orangefs_ioctl,
710 .mmap = orangefs_file_mmap,
711 .open = generic_file_open,
712 .release = orangefs_file_release,
713 .fsync = orangefs_fsync,