4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/file.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * ext2 fs regular file handling primitives
17 * 64-bit file support on 64-bit platforms by Jakub Jelinek
18 * (jj@sunsite.ms.mff.cuni.cz)
21 #include <linux/time.h>
22 #include <linux/pagemap.h>
23 #include <linux/dax.h>
24 #include <linux/quotaops.h>
25 #include <linux/iomap.h>
26 #include <linux/uio.h>
32 static ssize_t
ext2_dax_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
34 struct inode
*inode
= iocb
->ki_filp
->f_mapping
->host
;
37 if (!iov_iter_count(to
))
38 return 0; /* skip atime */
40 inode_lock_shared(inode
);
41 ret
= dax_iomap_rw(iocb
, to
, &ext2_iomap_ops
);
42 inode_unlock_shared(inode
);
44 file_accessed(iocb
->ki_filp
);
48 static ssize_t
ext2_dax_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
50 struct file
*file
= iocb
->ki_filp
;
51 struct inode
*inode
= file
->f_mapping
->host
;
55 ret
= generic_write_checks(iocb
, from
);
58 ret
= file_remove_privs(file
);
61 ret
= file_update_time(file
);
65 ret
= dax_iomap_rw(iocb
, from
, &ext2_iomap_ops
);
66 if (ret
> 0 && iocb
->ki_pos
> i_size_read(inode
)) {
67 i_size_write(inode
, iocb
->ki_pos
);
68 mark_inode_dirty(inode
);
74 ret
= generic_write_sync(iocb
, ret
);
79 * The lock ordering for ext2 DAX fault paths is:
82 * sb_start_pagefault (vfs, freeze)
83 * ext2_inode_info->dax_sem
84 * address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
85 * ext2_inode_info->truncate_mutex
87 * The default page_lock and i_size verification done by non-DAX fault paths
88 * is sufficient because ext2 doesn't support hole punching.
90 static int ext2_dax_fault(struct vm_fault
*vmf
)
92 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
93 struct ext2_inode_info
*ei
= EXT2_I(inode
);
96 if (vmf
->flags
& FAULT_FLAG_WRITE
) {
97 sb_start_pagefault(inode
->i_sb
);
98 file_update_time(vmf
->vma
->vm_file
);
100 down_read(&ei
->dax_sem
);
102 ret
= dax_iomap_fault(vmf
, PE_SIZE_PTE
, &ext2_iomap_ops
);
104 up_read(&ei
->dax_sem
);
105 if (vmf
->flags
& FAULT_FLAG_WRITE
)
106 sb_end_pagefault(inode
->i_sb
);
110 static const struct vm_operations_struct ext2_dax_vm_ops
= {
111 .fault
= ext2_dax_fault
,
113 * .huge_fault is not supported for DAX because allocation in ext2
114 * cannot be reliably aligned to huge page sizes and so pmd faults
115 * will always fail and fail back to regular faults.
117 .page_mkwrite
= ext2_dax_fault
,
118 .pfn_mkwrite
= ext2_dax_fault
,
121 static int ext2_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
123 if (!IS_DAX(file_inode(file
)))
124 return generic_file_mmap(file
, vma
);
127 vma
->vm_ops
= &ext2_dax_vm_ops
;
128 vma
->vm_flags
|= VM_MIXEDMAP
;
132 #define ext2_file_mmap generic_file_mmap
136 * Called when filp is released. This happens when all file descriptors
137 * for a single struct file are closed. Note that different open() calls
138 * for the same file yield different struct file structures.
140 static int ext2_release_file (struct inode
* inode
, struct file
* filp
)
142 if (filp
->f_mode
& FMODE_WRITE
) {
143 mutex_lock(&EXT2_I(inode
)->truncate_mutex
);
144 ext2_discard_reservation(inode
);
145 mutex_unlock(&EXT2_I(inode
)->truncate_mutex
);
150 int ext2_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
153 struct super_block
*sb
= file
->f_mapping
->host
->i_sb
;
155 ret
= generic_file_fsync(file
, start
, end
, datasync
);
157 /* We don't really know where the IO error happened... */
158 ext2_error(sb
, __func__
,
159 "detected IO error when writing metadata buffers");
163 static ssize_t
ext2_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
166 if (IS_DAX(iocb
->ki_filp
->f_mapping
->host
))
167 return ext2_dax_read_iter(iocb
, to
);
169 return generic_file_read_iter(iocb
, to
);
172 static ssize_t
ext2_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
175 if (IS_DAX(iocb
->ki_filp
->f_mapping
->host
))
176 return ext2_dax_write_iter(iocb
, from
);
178 return generic_file_write_iter(iocb
, from
);
181 const struct file_operations ext2_file_operations
= {
182 .llseek
= generic_file_llseek
,
183 .read_iter
= ext2_file_read_iter
,
184 .write_iter
= ext2_file_write_iter
,
185 .unlocked_ioctl
= ext2_ioctl
,
187 .compat_ioctl
= ext2_compat_ioctl
,
189 .mmap
= ext2_file_mmap
,
190 .open
= dquot_file_open
,
191 .release
= ext2_release_file
,
193 .get_unmapped_area
= thp_get_unmapped_area
,
194 .splice_read
= generic_file_splice_read
,
195 .splice_write
= iter_file_splice_write
,
198 const struct inode_operations ext2_file_inode_operations
= {
199 #ifdef CONFIG_EXT2_FS_XATTR
200 .listxattr
= ext2_listxattr
,
202 .setattr
= ext2_setattr
,
203 .get_acl
= ext2_get_acl
,
204 .set_acl
= ext2_set_acl
,
205 .fiemap
= ext2_fiemap
,