fs/ext2/file.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  linux/fs/ext2/file.c
0004  *
0005  * Copyright (C) 1992, 1993, 1994, 1995
0006  * Remy Card (card@masi.ibp.fr)
0007  * Laboratoire MASI - Institut Blaise Pascal
0008  * Universite Pierre et Marie Curie (Paris VI)
0009  *
0010  *  from
0011  *
0012  *  linux/fs/minix/file.c
0013  *
0014  *  Copyright (C) 1991, 1992  Linus Torvalds
0015  *
0016  *  ext2 fs regular file handling primitives
0017  *
0018  *  64-bit file support on 64-bit platforms by Jakub Jelinek
0019  *  (jj@sunsite.ms.mff.cuni.cz)
0020  */
0021
0022 #include <linux/time.h>
0023 #include <linux/pagemap.h>
0024 #include <linux/dax.h>
0025 #include <linux/quotaops.h>
0026 #include <linux/iomap.h>
0027 #include <linux/uio.h>
0028 #include "ext2.h"
0029 #include "xattr.h"
0030 #include "acl.h"
0031
0032 #ifdef CONFIG_FS_DAX
0033 static ssize_t ext2_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
0034 {
0035     struct inode *inode = iocb->ki_filp->f_mapping->host;
0036     ssize_t ret;
0037
0038     if (!iov_iter_count(to))
0039         return 0; /* skip atime */
0040
0041     inode_lock_shared(inode);
0042     ret = dax_iomap_rw(iocb, to, &ext2_iomap_ops);
0043     inode_unlock_shared(inode);
0044
0045     file_accessed(iocb->ki_filp);
0046     return ret;
0047 }
0048
0049 static ssize_t ext2_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
0050 {
0051     struct file *file = iocb->ki_filp;
0052     struct inode *inode = file->f_mapping->host;
0053     ssize_t ret;
0054
0055     inode_lock(inode);
0056     ret = generic_write_checks(iocb, from);
0057     if (ret <= 0)
0058         goto out_unlock;
0059     ret = file_remove_privs(file);
0060     if (ret)
0061         goto out_unlock;
0062     ret = file_update_time(file);
0063     if (ret)
0064         goto out_unlock;
0065
0066     ret = dax_iomap_rw(iocb, from, &ext2_iomap_ops);
0067     if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
0068         i_size_write(inode, iocb->ki_pos);
0069         mark_inode_dirty(inode);
0070     }
0071
0072 out_unlock:
0073     inode_unlock(inode);
0074     if (ret > 0)
0075         ret = generic_write_sync(iocb, ret);
0076     return ret;
0077 }
0078
0079 /*
0080  * The lock ordering for ext2 DAX fault paths is:
0081  *
0082  * mmap_lock (MM)
0083  *   sb_start_pagefault (vfs, freeze)
0084  *     address_space->invalidate_lock
0085  *       address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
0086  *         ext2_inode_info->truncate_mutex
0087  *
0088  * The default page_lock and i_size verification done by non-DAX fault paths
0089  * is sufficient because ext2 doesn't support hole punching.
0090  */
0091 static vm_fault_t ext2_dax_fault(struct vm_fault *vmf)
0092 {
0093     struct inode *inode = file_inode(vmf->vma->vm_file);
0094     vm_fault_t ret;
0095     bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
0096         (vmf->vma->vm_flags & VM_SHARED);
0097
0098     if (write) {
0099         sb_start_pagefault(inode->i_sb);
0100         file_update_time(vmf->vma->vm_file);
0101     }
0102     filemap_invalidate_lock_shared(inode->i_mapping);
0103
0104     ret = dax_iomap_fault(vmf, PE_SIZE_PTE, NULL, NULL, &ext2_iomap_ops);
0105
0106     filemap_invalidate_unlock_shared(inode->i_mapping);
0107     if (write)
0108         sb_end_pagefault(inode->i_sb);
0109     return ret;
0110 }
0111
0112 static const struct vm_operations_struct ext2_dax_vm_ops = {
0113     .fault      = ext2_dax_fault,
0114     /*
0115      * .huge_fault is not supported for DAX because allocation in ext2
0116      * cannot be reliably aligned to huge page sizes and so pmd faults
0117      * will always fail and fail back to regular faults.
0118      */
0119     .page_mkwrite   = ext2_dax_fault,
0120     .pfn_mkwrite    = ext2_dax_fault,
0121 };
0122
0123 static int ext2_file_mmap(struct file *file, struct vm_area_struct *vma)
0124 {
0125     if (!IS_DAX(file_inode(file)))
0126         return generic_file_mmap(file, vma);
0127
0128     file_accessed(file);
0129     vma->vm_ops = &ext2_dax_vm_ops;
0130     return 0;
0131 }
0132 #else
0133 #define ext2_file_mmap  generic_file_mmap
0134 #endif
0135
0136 /*
0137  * Called when filp is released. This happens when all file descriptors
0138  * for a single struct file are closed. Note that different open() calls
0139  * for the same file yield different struct file structures.
0140  */
0141 static int ext2_release_file (struct inode * inode, struct file * filp)
0142 {
0143     if (filp->f_mode & FMODE_WRITE) {
0144         mutex_lock(&EXT2_I(inode)->truncate_mutex);
0145         ext2_discard_reservation(inode);
0146         mutex_unlock(&EXT2_I(inode)->truncate_mutex);
0147     }
0148     return 0;
0149 }
0150
0151 int ext2_fsync(struct file *file, loff_t start, loff_t end, int datasync)
0152 {
0153     int ret;
0154     struct super_block *sb = file->f_mapping->host->i_sb;
0155
0156     ret = generic_file_fsync(file, start, end, datasync);
0157     if (ret == -EIO)
0158         /* We don't really know where the IO error happened... */
0159         ext2_error(sb, __func__,
0160                "detected IO error when writing metadata buffers");
0161     return ret;
0162 }
0163
0164 static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
0165 {
0166 #ifdef CONFIG_FS_DAX
0167     if (IS_DAX(iocb->ki_filp->f_mapping->host))
0168         return ext2_dax_read_iter(iocb, to);
0169 #endif
0170     return generic_file_read_iter(iocb, to);
0171 }
0172
0173 static ssize_t ext2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
0174 {
0175 #ifdef CONFIG_FS_DAX
0176     if (IS_DAX(iocb->ki_filp->f_mapping->host))
0177         return ext2_dax_write_iter(iocb, from);
0178 #endif
0179     return generic_file_write_iter(iocb, from);
0180 }
0181
0182 const struct file_operations ext2_file_operations = {
0183     .llseek     = generic_file_llseek,
0184     .read_iter  = ext2_file_read_iter,
0185     .write_iter = ext2_file_write_iter,
0186     .unlocked_ioctl = ext2_ioctl,
0187 #ifdef CONFIG_COMPAT
0188     .compat_ioctl   = ext2_compat_ioctl,
0189 #endif
0190     .mmap       = ext2_file_mmap,
0191     .open       = dquot_file_open,
0192     .release    = ext2_release_file,
0193     .fsync      = ext2_fsync,
0194     .get_unmapped_area = thp_get_unmapped_area,
0195     .splice_read    = generic_file_splice_read,
0196     .splice_write   = iter_file_splice_write,
0197 };
0198
0199 const struct inode_operations ext2_file_inode_operations = {
0200     .listxattr  = ext2_listxattr,
0201     .getattr    = ext2_getattr,
0202     .setattr    = ext2_setattr,
0203     .get_acl    = ext2_get_acl,
0204     .set_acl    = ext2_set_acl,
0205     .fiemap     = ext2_fiemap,
0206     .fileattr_get   = ext2_fileattr_get,
0207     .fileattr_set   = ext2_fileattr_set,
0208 };