1/*
2 *  linux/fs/ext2/file.c
3 *
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)
8 *
9 *  from
10 *
11 *  linux/fs/minix/file.c
12 *
13 *  Copyright (C) 1991, 1992  Linus Torvalds
14 *
15 *  ext2 fs regular file handling primitives
16 *
17 *  64-bit file support on 64-bit platforms by Jakub Jelinek
18 * 	(jj@sunsite.ms.mff.cuni.cz)
19 */
20
21#include <linux/time.h>
22#include <linux/pagemap.h>
23#include <linux/dax.h>
24#include <linux/quotaops.h>
25#include "ext2.h"
26#include "xattr.h"
27#include "acl.h"
28
29#ifdef CONFIG_FS_DAX
30/*
31 * The lock ordering for ext2 DAX fault paths is:
32 *
33 * mmap_sem (MM)
34 *   sb_start_pagefault (vfs, freeze)
35 *     ext2_inode_info->dax_sem
36 *       address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
37 *         ext2_inode_info->truncate_mutex
38 *
39 * The default page_lock and i_size verification done by non-DAX fault paths
40 * is sufficient because ext2 doesn't support hole punching.
41 */
42static int ext2_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
43{
44	struct inode *inode = file_inode(vma->vm_file);
45	struct ext2_inode_info *ei = EXT2_I(inode);
46	int ret;
47
48	if (vmf->flags & FAULT_FLAG_WRITE) {
49		sb_start_pagefault(inode->i_sb);
50		file_update_time(vma->vm_file);
51	}
52	down_read(&ei->dax_sem);
53
54	ret = __dax_fault(vma, vmf, ext2_get_block, NULL);
55
56	up_read(&ei->dax_sem);
57	if (vmf->flags & FAULT_FLAG_WRITE)
58		sb_end_pagefault(inode->i_sb);
59	return ret;
60}
61
62static int ext2_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
63						pmd_t *pmd, unsigned int flags)
64{
65	struct inode *inode = file_inode(vma->vm_file);
66	struct ext2_inode_info *ei = EXT2_I(inode);
67	int ret;
68
69	if (flags & FAULT_FLAG_WRITE) {
70		sb_start_pagefault(inode->i_sb);
71		file_update_time(vma->vm_file);
72	}
73	down_read(&ei->dax_sem);
74
75	ret = __dax_pmd_fault(vma, addr, pmd, flags, ext2_get_block, NULL);
76
77	up_read(&ei->dax_sem);
78	if (flags & FAULT_FLAG_WRITE)
79		sb_end_pagefault(inode->i_sb);
80	return ret;
81}
82
83static int ext2_dax_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
84{
85	struct inode *inode = file_inode(vma->vm_file);
86	struct ext2_inode_info *ei = EXT2_I(inode);
87	int ret;
88
89	sb_start_pagefault(inode->i_sb);
90	file_update_time(vma->vm_file);
91	down_read(&ei->dax_sem);
92
93	ret = __dax_mkwrite(vma, vmf, ext2_get_block, NULL);
94
95	up_read(&ei->dax_sem);
96	sb_end_pagefault(inode->i_sb);
97	return ret;
98}
99
100static int ext2_dax_pfn_mkwrite(struct vm_area_struct *vma,
101		struct vm_fault *vmf)
102{
103	struct inode *inode = file_inode(vma->vm_file);
104	struct ext2_inode_info *ei = EXT2_I(inode);
105	int ret = VM_FAULT_NOPAGE;
106	loff_t size;
107
108	sb_start_pagefault(inode->i_sb);
109	file_update_time(vma->vm_file);
110	down_read(&ei->dax_sem);
111
112	/* check that the faulting page hasn't raced with truncate */
113	size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
114	if (vmf->pgoff >= size)
115		ret = VM_FAULT_SIGBUS;
116
117	up_read(&ei->dax_sem);
118	sb_end_pagefault(inode->i_sb);
119	return ret;
120}
121
122static const struct vm_operations_struct ext2_dax_vm_ops = {
123	.fault		= ext2_dax_fault,
124	.pmd_fault	= ext2_dax_pmd_fault,
125	.page_mkwrite	= ext2_dax_mkwrite,
126	.pfn_mkwrite	= ext2_dax_pfn_mkwrite,
127};
128
129static int ext2_file_mmap(struct file *file, struct vm_area_struct *vma)
130{
131	if (!IS_DAX(file_inode(file)))
132		return generic_file_mmap(file, vma);
133
134	file_accessed(file);
135	vma->vm_ops = &ext2_dax_vm_ops;
136	vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
137	return 0;
138}
139#else
140#define ext2_file_mmap	generic_file_mmap
141#endif
142
143/*
144 * Called when filp is released. This happens when all file descriptors
145 * for a single struct file are closed. Note that different open() calls
146 * for the same file yield different struct file structures.
147 */
148static int ext2_release_file (struct inode * inode, struct file * filp)
149{
150	if (filp->f_mode & FMODE_WRITE) {
151		mutex_lock(&EXT2_I(inode)->truncate_mutex);
152		ext2_discard_reservation(inode);
153		mutex_unlock(&EXT2_I(inode)->truncate_mutex);
154	}
155	return 0;
156}
157
158int ext2_fsync(struct file *file, loff_t start, loff_t end, int datasync)
159{
160	int ret;
161	struct super_block *sb = file->f_mapping->host->i_sb;
162	struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
163
164	ret = generic_file_fsync(file, start, end, datasync);
165	if (ret == -EIO || test_and_clear_bit(AS_EIO, &mapping->flags)) {
166		/* We don't really know where the IO error happened... */
167		ext2_error(sb, __func__,
168			   "detected IO error when writing metadata buffers");
169		ret = -EIO;
170	}
171	return ret;
172}
173
174/*
175 * We have mostly NULL's here: the current defaults are ok for
176 * the ext2 filesystem.
177 */
178const struct file_operations ext2_file_operations = {
179	.llseek		= generic_file_llseek,
180	.read_iter	= generic_file_read_iter,
181	.write_iter	= generic_file_write_iter,
182	.unlocked_ioctl = ext2_ioctl,
183#ifdef CONFIG_COMPAT
184	.compat_ioctl	= ext2_compat_ioctl,
185#endif
186	.mmap		= ext2_file_mmap,
187	.open		= dquot_file_open,
188	.release	= ext2_release_file,
189	.fsync		= ext2_fsync,
190	.splice_read	= generic_file_splice_read,
191	.splice_write	= iter_file_splice_write,
192};
193
194const struct inode_operations ext2_file_inode_operations = {
195#ifdef CONFIG_EXT2_FS_XATTR
196	.setxattr	= generic_setxattr,
197	.getxattr	= generic_getxattr,
198	.listxattr	= ext2_listxattr,
199	.removexattr	= generic_removexattr,
200#endif
201	.setattr	= ext2_setattr,
202	.get_acl	= ext2_get_acl,
203	.set_acl	= ext2_set_acl,
204	.fiemap		= ext2_fiemap,
205};
206