blob: 510e66422f045bd92b3631671ed3b72d9b39ec7f [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/file.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
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 *
Mingming Cao617ba132006-10-11 01:20:53 -070015 * ext4 fs regular file handling primitives
Dave Kleikampac27a0e2006-10-11 01:20:50 -070016 *
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/fs.h>
Theodore Ts'obc0b0d62009-06-13 10:09:48 -040023#include <linux/mount.h>
24#include <linux/path.h>
Matthew Wilcoxc94c2ac2015-09-08 14:58:40 -070025#include <linux/dax.h>
Christoph Hellwig871a2932010-03-03 09:05:07 -050026#include <linux/quotaops.h>
Zheng Liuc8c0df22012-11-08 21:57:40 -050027#include <linux/pagevec.h>
Christoph Hellwige2e40f22015-02-22 08:58:50 -080028#include <linux/uio.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040029#include "ext4.h"
30#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070031#include "xattr.h"
32#include "acl.h"
33
34/*
35 * Called when an inode is released. Note that this is different
Mingming Cao617ba132006-10-11 01:20:53 -070036 * from ext4_file_open: open gets called at every open, but release
Dave Kleikampac27a0e2006-10-11 01:20:50 -070037 * gets called only when /all/ the files are closed.
38 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -040039static int ext4_release_file(struct inode *inode, struct file *filp)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070040{
Theodore Ts'o19f5fb72010-01-24 14:34:07 -050041 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
Theodore Ts'o7d8f9f72009-02-24 08:21:14 -050042 ext4_alloc_da_blocks(inode);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -050043 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
Theodore Ts'o7d8f9f72009-02-24 08:21:14 -050044 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -070045 /* if we are the last writer on the inode, drop the block reservation */
46 if ((filp->f_mode & FMODE_WRITE) &&
Aneesh Kumar K.Vd6014302009-03-27 22:36:43 -040047 (atomic_read(&inode->i_writecount) == 1) &&
48 !EXT4_I(inode)->i_reserved_data_blocks)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070049 {
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -050050 down_write(&EXT4_I(inode)->i_data_sem);
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -040051 ext4_discard_preallocations(inode);
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -050052 up_write(&EXT4_I(inode)->i_data_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070053 }
54 if (is_dx(inode) && filp->private_data)
Mingming Cao617ba132006-10-11 01:20:53 -070055 ext4_htree_free_dir_info(filp->private_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070056
57 return 0;
58}
59
Stephen Hemmingerc1978552014-05-12 10:50:23 -040060static void ext4_unwritten_wait(struct inode *inode)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050061{
62 wait_queue_head_t *wq = ext4_ioend_wq(inode);
63
Dmitry Monakhove27f41e2012-09-28 23:24:52 -040064 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
Eric Sandeene9e3bce2011-02-12 08:17:34 -050065}
66
67/*
68 * This tests whether the IO in question is block-aligned or not.
69 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
70 * are converted to written only after the IO is complete. Until they are
71 * mapped, these blocks appear as holes, so dio_zero_block() will assume that
72 * it needs to zero out portions of the start and/or end block. If 2 AIO
73 * threads are at work on the same unwritten block, they must be synchronized
74 * or one thread will zero the other's data, causing corruption.
75 */
76static int
Al Viro9b884162014-04-17 16:09:22 -040077ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050078{
79 struct super_block *sb = inode->i_sb;
80 int blockmask = sb->s_blocksize - 1;
Eric Sandeene9e3bce2011-02-12 08:17:34 -050081
Theodore Ts'o6e6358f2014-04-12 12:45:25 -040082 if (pos >= i_size_read(inode))
Eric Sandeene9e3bce2011-02-12 08:17:34 -050083 return 0;
84
Al Viro9b884162014-04-17 16:09:22 -040085 if ((pos | iov_iter_alignment(from)) & blockmask)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050086 return 1;
87
88 return 0;
89}
90
Dave Kleikampac27a0e2006-10-11 01:20:50 -070091static ssize_t
Al Viro9b884162014-04-17 16:09:22 -040092ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070093{
Al Viro496ad9a2013-01-23 17:07:38 -050094 struct inode *inode = file_inode(iocb->ki_filp);
Al Viro2ba48ce2015-04-09 13:52:01 -040095 int o_direct = iocb->ki_flags & IOCB_DIRECT;
Jan Karae142d052016-03-08 22:44:50 -050096 int unaligned_aio = 0;
Theodore Ts'o8ad28502014-04-21 14:26:57 -040097 int overwrite = 0;
Zheng Liu85630002012-05-28 18:06:51 -040098 ssize_t ret;
Theodore Ts'o7608e612014-04-21 14:26:28 -040099
Al Viro59551022016-01-22 15:40:57 -0500100 inode_lock(inode);
Al Viro3309dd02015-04-09 12:55:47 -0400101 ret = generic_write_checks(iocb, from);
102 if (ret <= 0)
Al Viroe768d7f2015-04-07 14:48:22 -0400103 goto out;
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400104
105 /*
Jan Karae142d052016-03-08 22:44:50 -0500106 * Unaligned direct AIO must be serialized among each other as zeroing
107 * of partial blocks of two competing unaligned AIOs can result in data
108 * corruption.
109 */
110 if (o_direct && ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
111 !is_sync_kiocb(iocb) &&
112 ext4_unaligned_aio(inode, from, iocb->ki_pos)) {
113 unaligned_aio = 1;
114 ext4_unwritten_wait(inode);
115 }
116
117 /*
Eric Sandeene2b46572008-01-28 23:58:27 -0500118 * If we have encountered a bitmap-format file, the size limit
119 * is smaller than s_maxbytes, which is for extent-mapped files.
120 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400121 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
Eric Sandeene2b46572008-01-28 23:58:27 -0500122 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Eric Sandeene2b46572008-01-28 23:58:27 -0500123
Al Viro3309dd02015-04-09 12:55:47 -0400124 if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) {
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400125 ret = -EFBIG;
Al Viroe768d7f2015-04-07 14:48:22 -0400126 goto out;
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400127 }
Al Viro3309dd02015-04-09 12:55:47 -0400128 iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
Eric Sandeene2b46572008-01-28 23:58:27 -0500129 }
130
Dmitry Monakhova41537e2014-10-30 10:53:16 -0400131 iocb->private = &overwrite;
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400132 if (o_direct) {
Al Viro3309dd02015-04-09 12:55:47 -0400133 size_t length = iov_iter_count(from);
134 loff_t pos = iocb->ki_pos;
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400135
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400136 /* check whether we do a DIO overwrite or not */
Jan Karae142d052016-03-08 22:44:50 -0500137 if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
Jan Kara4b0524a2016-09-30 01:55:32 -0400138 pos + length <= i_size_read(inode)) {
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400139 struct ext4_map_blocks map;
140 unsigned int blkbits = inode->i_blkbits;
141 int err, len;
142
143 map.m_lblk = pos >> blkbits;
Fabian Frederick518eaa62016-09-15 11:55:01 -0400144 map.m_len = EXT4_MAX_BLOCKS(length, pos, blkbits);
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400145 len = map.m_len;
146
147 err = ext4_map_blocks(NULL, inode, &map, 0);
148 /*
149 * 'err==len' means that all of blocks has
150 * been preallocated no matter they are
151 * initialized or not. For excluding
152 * unwritten extents, we need to check
153 * m_flags. There are two conditions that
154 * indicate for initialized extents. 1) If we
155 * hit extent cache, EXT4_MAP_MAPPED flag is
156 * returned; 2) If we do a real lookup,
157 * non-flags are returned. So we should check
158 * these two conditions.
159 */
160 if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
161 overwrite = 1;
162 }
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400163 }
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400164
Al Viro9b884162014-04-17 16:09:22 -0400165 ret = __generic_file_write_iter(iocb, from);
Al Viro59551022016-01-22 15:40:57 -0500166 inode_unlock(inode);
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400167
Christoph Hellwige2592212016-04-07 08:52:01 -0700168 if (ret > 0)
169 ret = generic_write_sync(iocb, ret);
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400170
Al Viroe768d7f2015-04-07 14:48:22 -0400171 return ret;
172
173out:
Al Viro59551022016-01-22 15:40:57 -0500174 inode_unlock(inode);
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500175 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700176}
177
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800178#ifdef CONFIG_FS_DAX
179static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
180{
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700181 int result;
182 handle_t *handle = NULL;
Jan Karaea3d7202015-12-07 14:28:03 -0500183 struct inode *inode = file_inode(vma->vm_file);
184 struct super_block *sb = inode->i_sb;
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700185 bool write = vmf->flags & FAULT_FLAG_WRITE;
186
187 if (write) {
188 sb_start_pagefault(sb);
189 file_update_time(vma->vm_file);
Jan Karaea3d7202015-12-07 14:28:03 -0500190 down_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700191 handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
192 EXT4_DATA_TRANS_BLOCKS(sb));
Jan Karaea3d7202015-12-07 14:28:03 -0500193 } else
194 down_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700195
196 if (IS_ERR(handle))
197 result = VM_FAULT_SIGBUS;
198 else
Ross Zwisler6b524992016-07-26 15:21:05 -0700199 result = dax_fault(vma, vmf, ext4_dax_get_block);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700200
201 if (write) {
202 if (!IS_ERR(handle))
203 ext4_journal_stop(handle);
Jan Karaea3d7202015-12-07 14:28:03 -0500204 up_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700205 sb_end_pagefault(sb);
Jan Karaea3d7202015-12-07 14:28:03 -0500206 } else
207 up_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700208
209 return result;
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800210}
211
Matthew Wilcox11bd1a92015-09-08 14:59:03 -0700212static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
213 pmd_t *pmd, unsigned int flags)
214{
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700215 int result;
216 handle_t *handle = NULL;
217 struct inode *inode = file_inode(vma->vm_file);
218 struct super_block *sb = inode->i_sb;
219 bool write = flags & FAULT_FLAG_WRITE;
220
221 if (write) {
222 sb_start_pagefault(sb);
223 file_update_time(vma->vm_file);
Jan Karaea3d7202015-12-07 14:28:03 -0500224 down_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700225 handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
226 ext4_chunk_trans_blocks(inode,
227 PMD_SIZE / PAGE_SIZE));
Jan Karaea3d7202015-12-07 14:28:03 -0500228 } else
229 down_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700230
231 if (IS_ERR(handle))
232 result = VM_FAULT_SIGBUS;
233 else
Ross Zwisler6b524992016-07-26 15:21:05 -0700234 result = dax_pmd_fault(vma, addr, pmd, flags,
Jan Kara02fbd132016-05-11 11:58:48 +0200235 ext4_dax_get_block);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700236
237 if (write) {
238 if (!IS_ERR(handle))
239 ext4_journal_stop(handle);
Jan Karaea3d7202015-12-07 14:28:03 -0500240 up_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700241 sb_end_pagefault(sb);
Jan Karaea3d7202015-12-07 14:28:03 -0500242 } else
243 up_read(&EXT4_I(inode)->i_mmap_sem);
Matthew Wilcox01a33b42015-09-08 14:59:22 -0700244
245 return result;
Matthew Wilcox11bd1a92015-09-08 14:59:03 -0700246}
247
Jan Karaea3d7202015-12-07 14:28:03 -0500248/*
Ross Zwisler1e9d1802016-02-27 14:01:13 -0500249 * Handle write fault for VM_MIXEDMAP mappings. Similarly to ext4_dax_fault()
Jan Karaea3d7202015-12-07 14:28:03 -0500250 * handler we check for races agaist truncate. Note that since we cycle through
251 * i_mmap_sem, we are sure that also any hole punching that began before we
252 * were called is finished by now and so if it included part of the file we
253 * are working on, our pte will get unmapped and the check for pte_same() in
254 * wp_pfn_shared() fails. Thus fault gets retried and things work out as
255 * desired.
256 */
257static int ext4_dax_pfn_mkwrite(struct vm_area_struct *vma,
258 struct vm_fault *vmf)
259{
260 struct inode *inode = file_inode(vma->vm_file);
261 struct super_block *sb = inode->i_sb;
Jan Karaea3d7202015-12-07 14:28:03 -0500262 loff_t size;
Ross Zwislerd5be7a02016-01-22 15:10:53 -0800263 int ret;
Jan Karaea3d7202015-12-07 14:28:03 -0500264
265 sb_start_pagefault(sb);
266 file_update_time(vma->vm_file);
267 down_read(&EXT4_I(inode)->i_mmap_sem);
268 size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
269 if (vmf->pgoff >= size)
270 ret = VM_FAULT_SIGBUS;
Ross Zwislerd5be7a02016-01-22 15:10:53 -0800271 else
272 ret = dax_pfn_mkwrite(vma, vmf);
Jan Karaea3d7202015-12-07 14:28:03 -0500273 up_read(&EXT4_I(inode)->i_mmap_sem);
274 sb_end_pagefault(sb);
275
276 return ret;
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800277}
278
279static const struct vm_operations_struct ext4_dax_vm_ops = {
280 .fault = ext4_dax_fault,
Matthew Wilcox11bd1a92015-09-08 14:59:03 -0700281 .pmd_fault = ext4_dax_pmd_fault,
Ross Zwisler1e9d1802016-02-27 14:01:13 -0500282 .page_mkwrite = ext4_dax_fault,
Jan Karaea3d7202015-12-07 14:28:03 -0500283 .pfn_mkwrite = ext4_dax_pfn_mkwrite,
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800284};
285#else
286#define ext4_dax_vm_ops ext4_file_vm_ops
287#endif
288
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400289static const struct vm_operations_struct ext4_file_vm_ops = {
Jan Karaea3d7202015-12-07 14:28:03 -0500290 .fault = ext4_filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -0700291 .map_pages = filemap_map_pages,
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400292 .page_mkwrite = ext4_page_mkwrite,
293};
294
295static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
296{
Michael Halcrowc9c74292015-04-12 00:56:10 -0400297 struct inode *inode = file->f_mapping->host;
298
299 if (ext4_encrypted_inode(inode)) {
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400300 int err = fscrypt_get_encryption_info(inode);
Michael Halcrowc9c74292015-04-12 00:56:10 -0400301 if (err)
302 return 0;
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400303 if (!fscrypt_has_encryption_key(inode))
Theodore Ts'oabdd4382015-05-31 13:35:39 -0400304 return -ENOKEY;
Michael Halcrowc9c74292015-04-12 00:56:10 -0400305 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400306 file_accessed(file);
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800307 if (IS_DAX(file_inode(file))) {
308 vma->vm_ops = &ext4_dax_vm_ops;
Matthew Wilcox11bd1a92015-09-08 14:59:03 -0700309 vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800310 } else {
311 vma->vm_ops = &ext4_file_vm_ops;
312 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400313 return 0;
314}
315
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400316static int ext4_file_open(struct inode * inode, struct file * filp)
317{
318 struct super_block *sb = inode->i_sb;
319 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
320 struct vfsmount *mnt = filp->f_path.mnt;
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400321 struct dentry *dir;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400322 struct path path;
323 char buf[64], *cp;
Michael Halcrowc9c74292015-04-12 00:56:10 -0400324 int ret;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400325
326 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
327 !(sb->s_flags & MS_RDONLY))) {
328 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
329 /*
330 * Sample where the filesystem has been mounted and
331 * store it in the superblock for sysadmin convenience
332 * when trying to sort through large numbers of block
333 * devices or filesystem images.
334 */
335 memset(buf, 0, sizeof(buf));
Al Viro38991672010-01-23 20:10:29 -0500336 path.mnt = mnt;
337 path.dentry = mnt->mnt_root;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400338 cp = d_path(&path, buf, sizeof(buf));
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400339 if (!IS_ERR(cp)) {
Jan Kara044ce472012-07-22 20:31:31 -0400340 handle_t *handle;
341 int err;
342
Theodore Ts'o9924a922013-02-08 21:59:22 -0500343 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
Jan Kara044ce472012-07-22 20:31:31 -0400344 if (IS_ERR(handle))
345 return PTR_ERR(handle);
liang xie5d601252014-05-12 22:06:43 -0400346 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
Jan Kara044ce472012-07-22 20:31:31 -0400347 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
348 if (err) {
349 ext4_journal_stop(handle);
350 return err;
351 }
Darrick J. Wongcf803902011-10-25 09:18:41 -0400352 strlcpy(sbi->s_es->s_last_mounted, cp,
353 sizeof(sbi->s_es->s_last_mounted));
Jan Kara044ce472012-07-22 20:31:31 -0400354 ext4_handle_dirty_super(handle, sb);
355 ext4_journal_stop(handle);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400356 }
357 }
Theodore Ts'oabdd4382015-05-31 13:35:39 -0400358 if (ext4_encrypted_inode(inode)) {
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400359 ret = fscrypt_get_encryption_info(inode);
Theodore Ts'oabdd4382015-05-31 13:35:39 -0400360 if (ret)
361 return -EACCES;
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400362 if (!fscrypt_has_encryption_key(inode))
Theodore Ts'oabdd4382015-05-31 13:35:39 -0400363 return -ENOKEY;
364 }
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400365
Miklos Szeredic0a37d4872016-03-26 16:14:42 -0400366 dir = dget_parent(file_dentry(filp));
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400367 if (ext4_encrypted_inode(d_inode(dir)) &&
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400368 !fscrypt_has_permitted_context(d_inode(dir), inode)) {
Theodore Ts'off978b02016-02-08 00:54:26 -0500369 ext4_warning(inode->i_sb,
Jakub Wilk8d2ae1c2016-04-27 01:11:21 -0400370 "Inconsistent encryption contexts: %lu/%lu",
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400371 (unsigned long) d_inode(dir)->i_ino,
Theodore Ts'off978b02016-02-08 00:54:26 -0500372 (unsigned long) inode->i_ino);
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400373 dput(dir);
Theodore Ts'off978b02016-02-08 00:54:26 -0500374 return -EPERM;
375 }
Miklos Szeredi9dd78d82016-03-26 16:14:41 -0400376 dput(dir);
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500377 /*
378 * Set up the jbd2_inode if we are opening the inode for
379 * writing and the journal is present
380 */
Jan Karaa3612932013-08-16 21:19:41 -0400381 if (filp->f_mode & FMODE_WRITE) {
Michael Halcrowc9c74292015-04-12 00:56:10 -0400382 ret = ext4_inode_attach_jinode(inode);
Jan Karaa3612932013-08-16 21:19:41 -0400383 if (ret < 0)
384 return ret;
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500385 }
Theodore Ts'oabdd4382015-05-31 13:35:39 -0400386 return dquot_file_open(inode, filp);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400387}
388
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400389/*
Zheng Liuc8c0df22012-11-08 21:57:40 -0500390 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
391 * file rather than ext4_ext_walk_space() because we can introduce
392 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
393 * function. When extent status tree has been fully implemented, it will
394 * track all extent status for a file and we can directly use it to
395 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
396 */
397
398/*
399 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
400 * lookup page cache to check whether or not there has some data between
401 * [startoff, endoff] because, if this range contains an unwritten extent,
402 * we determine this extent as a data or a hole according to whether the
403 * page cache has data or not.
404 */
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500405static int ext4_find_unwritten_pgoff(struct inode *inode,
406 int whence,
Jan Kara2d90c162016-03-09 23:11:13 -0500407 ext4_lblk_t end_blk,
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500408 loff_t *offset)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500409{
410 struct pagevec pvec;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500411 unsigned int blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500412 pgoff_t index;
413 pgoff_t end;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500414 loff_t endoff;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500415 loff_t startoff;
416 loff_t lastoff;
417 int found = 0;
418
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500419 blkbits = inode->i_sb->s_blocksize_bits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500420 startoff = *offset;
421 lastoff = startoff;
Jan Kara2d90c162016-03-09 23:11:13 -0500422 endoff = (loff_t)end_blk << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500423
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300424 index = startoff >> PAGE_SHIFT;
425 end = endoff >> PAGE_SHIFT;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500426
427 pagevec_init(&pvec, 0);
428 do {
429 int i, num;
430 unsigned long nr_pages;
431
432 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
433 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
434 (pgoff_t)num);
Jan Kara98508442017-05-21 22:33:23 -0400435 if (nr_pages == 0)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500436 break;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500437
438 for (i = 0; i < nr_pages; i++) {
439 struct page *page = pvec.pages[i];
440 struct buffer_head *bh, *head;
441
442 /*
Jan Kara98508442017-05-21 22:33:23 -0400443 * If current offset is smaller than the page offset,
444 * there is a hole at this offset.
Zheng Liuc8c0df22012-11-08 21:57:40 -0500445 */
Jan Kara98508442017-05-21 22:33:23 -0400446 if (whence == SEEK_HOLE && lastoff < endoff &&
447 lastoff < page_offset(pvec.pages[i])) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500448 found = 1;
449 *offset = lastoff;
450 goto out;
451 }
452
Jan Kara98508442017-05-21 22:33:23 -0400453 if (page->index > end)
454 goto out;
455
Zheng Liuc8c0df22012-11-08 21:57:40 -0500456 lock_page(page);
457
458 if (unlikely(page->mapping != inode->i_mapping)) {
459 unlock_page(page);
460 continue;
461 }
462
463 if (!page_has_buffers(page)) {
464 unlock_page(page);
465 continue;
466 }
467
468 if (page_has_buffers(page)) {
469 lastoff = page_offset(page);
470 bh = head = page_buffers(page);
471 do {
Jan Kara0814c3a2017-08-05 17:43:24 -0400472 if (lastoff + bh->b_size <= startoff)
473 goto next;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500474 if (buffer_uptodate(bh) ||
475 buffer_unwritten(bh)) {
Andrew Morton965c8e52012-12-17 15:59:39 -0800476 if (whence == SEEK_DATA)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500477 found = 1;
478 } else {
Andrew Morton965c8e52012-12-17 15:59:39 -0800479 if (whence == SEEK_HOLE)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500480 found = 1;
481 }
482 if (found) {
483 *offset = max_t(loff_t,
484 startoff, lastoff);
485 unlock_page(page);
486 goto out;
487 }
Jan Kara0814c3a2017-08-05 17:43:24 -0400488next:
Zheng Liuc8c0df22012-11-08 21:57:40 -0500489 lastoff += bh->b_size;
490 bh = bh->b_this_page;
491 } while (bh != head);
492 }
493
494 lastoff = page_offset(page) + PAGE_SIZE;
495 unlock_page(page);
496 }
497
Jan Kara98508442017-05-21 22:33:23 -0400498 /* The no. of pages is less than our desired, we are done. */
499 if (nr_pages < num)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500500 break;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500501
502 index = pvec.pages[i - 1]->index + 1;
503 pagevec_release(&pvec);
504 } while (index <= end);
505
Jan Kara98508442017-05-21 22:33:23 -0400506 if (whence == SEEK_HOLE && lastoff < endoff) {
507 found = 1;
508 *offset = lastoff;
509 }
Zheng Liuc8c0df22012-11-08 21:57:40 -0500510out:
511 pagevec_release(&pvec);
512 return found;
513}
514
515/*
516 * ext4_seek_data() retrieves the offset for SEEK_DATA.
517 */
518static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
519{
520 struct inode *inode = file->f_mapping->host;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500521 struct extent_status es;
522 ext4_lblk_t start, last, end;
523 loff_t dataoff, isize;
524 int blkbits;
Jan Kara2d90c162016-03-09 23:11:13 -0500525 int ret;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500526
Al Viro59551022016-01-22 15:40:57 -0500527 inode_lock(inode);
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500528
529 isize = i_size_read(inode);
Darrick J. Wong28cbf062017-08-24 13:22:06 -0400530 if (offset < 0 || offset >= isize) {
Al Viro59551022016-01-22 15:40:57 -0500531 inode_unlock(inode);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500532 return -ENXIO;
533 }
534
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500535 blkbits = inode->i_sb->s_blocksize_bits;
536 start = offset >> blkbits;
537 last = start;
538 end = isize >> blkbits;
539 dataoff = offset;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500540
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500541 do {
Jan Kara2d90c162016-03-09 23:11:13 -0500542 ret = ext4_get_next_extent(inode, last, end - last + 1, &es);
543 if (ret <= 0) {
544 /* No extent found -> no data */
545 if (ret == 0)
546 ret = -ENXIO;
547 inode_unlock(inode);
548 return ret;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500549 }
550
Jan Kara2d90c162016-03-09 23:11:13 -0500551 last = es.es_lblk;
552 if (last != start)
553 dataoff = (loff_t)last << blkbits;
554 if (!ext4_es_is_unwritten(&es))
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500555 break;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500556
557 /*
558 * If there is a unwritten extent at this offset,
559 * it will be as a data or a hole according to page
560 * cache that has data or not.
561 */
Jan Kara2d90c162016-03-09 23:11:13 -0500562 if (ext4_find_unwritten_pgoff(inode, SEEK_DATA,
563 es.es_lblk + es.es_len, &dataoff))
564 break;
565 last += es.es_len;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500566 dataoff = (loff_t)last << blkbits;
Jan Kara2d90c162016-03-09 23:11:13 -0500567 cond_resched();
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500568 } while (last <= end);
569
Al Viro59551022016-01-22 15:40:57 -0500570 inode_unlock(inode);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500571
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500572 if (dataoff > isize)
573 return -ENXIO;
574
575 return vfs_setpos(file, dataoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500576}
577
578/*
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500579 * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
Zheng Liuc8c0df22012-11-08 21:57:40 -0500580 */
581static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
582{
583 struct inode *inode = file->f_mapping->host;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500584 struct extent_status es;
585 ext4_lblk_t start, last, end;
586 loff_t holeoff, isize;
587 int blkbits;
Jan Kara2d90c162016-03-09 23:11:13 -0500588 int ret;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500589
Al Viro59551022016-01-22 15:40:57 -0500590 inode_lock(inode);
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500591
592 isize = i_size_read(inode);
Darrick J. Wong28cbf062017-08-24 13:22:06 -0400593 if (offset < 0 || offset >= isize) {
Al Viro59551022016-01-22 15:40:57 -0500594 inode_unlock(inode);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500595 return -ENXIO;
596 }
597
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500598 blkbits = inode->i_sb->s_blocksize_bits;
599 start = offset >> blkbits;
600 last = start;
601 end = isize >> blkbits;
602 holeoff = offset;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500603
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500604 do {
Jan Kara2d90c162016-03-09 23:11:13 -0500605 ret = ext4_get_next_extent(inode, last, end - last + 1, &es);
606 if (ret < 0) {
607 inode_unlock(inode);
608 return ret;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500609 }
Jan Kara2d90c162016-03-09 23:11:13 -0500610 /* Found a hole? */
611 if (ret == 0 || es.es_lblk > last) {
612 if (last != start)
613 holeoff = (loff_t)last << blkbits;
614 break;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500615 }
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500616 /*
617 * If there is a unwritten extent at this offset,
618 * it will be as a data or a hole according to page
619 * cache that has data or not.
620 */
Jan Kara2d90c162016-03-09 23:11:13 -0500621 if (ext4_es_is_unwritten(&es) &&
622 ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
623 last + es.es_len, &holeoff))
624 break;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500625
Jan Kara2d90c162016-03-09 23:11:13 -0500626 last += es.es_len;
627 holeoff = (loff_t)last << blkbits;
628 cond_resched();
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500629 } while (last <= end);
630
Al Viro59551022016-01-22 15:40:57 -0500631 inode_unlock(inode);
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500632
633 if (holeoff > isize)
634 holeoff = isize;
635
636 return vfs_setpos(file, holeoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500637}
638
639/*
Eric Sandeenec7268c2012-04-30 13:14:03 -0500640 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
641 * by calling generic_file_llseek_size() with the appropriate maxbytes
642 * value for each.
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400643 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800644loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400645{
646 struct inode *inode = file->f_mapping->host;
647 loff_t maxbytes;
648
649 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
650 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
651 else
652 maxbytes = inode->i_sb->s_maxbytes;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400653
Andrew Morton965c8e52012-12-17 15:59:39 -0800654 switch (whence) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500655 case SEEK_SET:
656 case SEEK_CUR:
657 case SEEK_END:
Andrew Morton965c8e52012-12-17 15:59:39 -0800658 return generic_file_llseek_size(file, offset, whence,
Zheng Liuc8c0df22012-11-08 21:57:40 -0500659 maxbytes, i_size_read(inode));
660 case SEEK_DATA:
661 return ext4_seek_data(file, offset, maxbytes);
662 case SEEK_HOLE:
663 return ext4_seek_hole(file, offset, maxbytes);
664 }
665
666 return -EINVAL;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400667}
668
Mingming Cao617ba132006-10-11 01:20:53 -0700669const struct file_operations ext4_file_operations = {
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400670 .llseek = ext4_llseek,
Al Viroaad4f8b2014-04-02 14:33:16 -0400671 .read_iter = generic_file_read_iter,
Al Viro9b884162014-04-17 16:09:22 -0400672 .write_iter = ext4_file_write_iter,
Andi Kleen5cdd7b22008-04-29 22:03:54 -0400673 .unlocked_ioctl = ext4_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700674#ifdef CONFIG_COMPAT
Mingming Cao617ba132006-10-11 01:20:53 -0700675 .compat_ioctl = ext4_compat_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700676#endif
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400677 .mmap = ext4_file_mmap,
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400678 .open = ext4_file_open,
Mingming Cao617ba132006-10-11 01:20:53 -0700679 .release = ext4_release_file,
680 .fsync = ext4_sync_file,
Toshi Kanidbe6ec82016-10-07 16:59:59 -0700681 .get_unmapped_area = thp_get_unmapped_area,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700682 .splice_read = generic_file_splice_read,
Al Viro8d020762014-04-05 04:27:08 -0400683 .splice_write = iter_file_splice_write,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100684 .fallocate = ext4_fallocate,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685};
686
Arjan van de Ven754661f2007-02-12 00:55:38 -0800687const struct inode_operations ext4_file_inode_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -0700688 .setattr = ext4_setattr,
Mingming Cao3e3398a2008-07-11 19:27:31 -0400689 .getattr = ext4_getattr,
Mingming Cao617ba132006-10-11 01:20:53 -0700690 .listxattr = ext4_listxattr,
Christoph Hellwig4e34e712011-07-23 17:37:31 +0200691 .get_acl = ext4_get_acl,
Christoph Hellwig64e178a2013-12-20 05:16:44 -0800692 .set_acl = ext4_set_acl,
Eric Sandeen6873fa02008-10-07 00:46:36 -0400693 .fiemap = ext4_fiemap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700694};
695