blob: 0613c256c3441a208f51291dbc2691489cf4dd9c [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>
Christoph Hellwig871a2932010-03-03 09:05:07 -050025#include <linux/quotaops.h>
Zheng Liuc8c0df22012-11-08 21:57:40 -050026#include <linux/pagevec.h>
Christoph Hellwige2e40f22015-02-22 08:58:50 -080027#include <linux/uio.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040028#include "ext4.h"
29#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070030#include "xattr.h"
31#include "acl.h"
32
33/*
34 * Called when an inode is released. Note that this is different
Mingming Cao617ba132006-10-11 01:20:53 -070035 * from ext4_file_open: open gets called at every open, but release
Dave Kleikampac27a0e2006-10-11 01:20:50 -070036 * gets called only when /all/ the files are closed.
37 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -040038static int ext4_release_file(struct inode *inode, struct file *filp)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070039{
Theodore Ts'o19f5fb72010-01-24 14:34:07 -050040 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
Theodore Ts'o7d8f9f72009-02-24 08:21:14 -050041 ext4_alloc_da_blocks(inode);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -050042 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
Theodore Ts'o7d8f9f72009-02-24 08:21:14 -050043 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -070044 /* if we are the last writer on the inode, drop the block reservation */
45 if ((filp->f_mode & FMODE_WRITE) &&
Aneesh Kumar K.Vd6014302009-03-27 22:36:43 -040046 (atomic_read(&inode->i_writecount) == 1) &&
47 !EXT4_I(inode)->i_reserved_data_blocks)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070048 {
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -050049 down_write(&EXT4_I(inode)->i_data_sem);
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -040050 ext4_discard_preallocations(inode);
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -050051 up_write(&EXT4_I(inode)->i_data_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070052 }
53 if (is_dx(inode) && filp->private_data)
Mingming Cao617ba132006-10-11 01:20:53 -070054 ext4_htree_free_dir_info(filp->private_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070055
56 return 0;
57}
58
Stephen Hemmingerc1978552014-05-12 10:50:23 -040059static void ext4_unwritten_wait(struct inode *inode)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050060{
61 wait_queue_head_t *wq = ext4_ioend_wq(inode);
62
Dmitry Monakhove27f41e2012-09-28 23:24:52 -040063 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
Eric Sandeene9e3bce2011-02-12 08:17:34 -050064}
65
66/*
67 * This tests whether the IO in question is block-aligned or not.
68 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
69 * are converted to written only after the IO is complete. Until they are
70 * mapped, these blocks appear as holes, so dio_zero_block() will assume that
71 * it needs to zero out portions of the start and/or end block. If 2 AIO
72 * threads are at work on the same unwritten block, they must be synchronized
73 * or one thread will zero the other's data, causing corruption.
74 */
75static int
Al Viro9b884162014-04-17 16:09:22 -040076ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050077{
78 struct super_block *sb = inode->i_sb;
79 int blockmask = sb->s_blocksize - 1;
Eric Sandeene9e3bce2011-02-12 08:17:34 -050080
Theodore Ts'o6e6358f2014-04-12 12:45:25 -040081 if (pos >= i_size_read(inode))
Eric Sandeene9e3bce2011-02-12 08:17:34 -050082 return 0;
83
Al Viro9b884162014-04-17 16:09:22 -040084 if ((pos | iov_iter_alignment(from)) & blockmask)
Eric Sandeene9e3bce2011-02-12 08:17:34 -050085 return 1;
86
87 return 0;
88}
89
Dave Kleikampac27a0e2006-10-11 01:20:50 -070090static ssize_t
Al Viro9b884162014-04-17 16:09:22 -040091ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070092{
Theodore Ts'o7608e612014-04-21 14:26:28 -040093 struct file *file = iocb->ki_filp;
Al Viro496ad9a2013-01-23 17:07:38 -050094 struct inode *inode = file_inode(iocb->ki_filp);
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -040095 struct mutex *aio_mutex = NULL;
Theodore Ts'o8ad28502014-04-21 14:26:57 -040096 struct blk_plug plug;
Al Viro2ba48ce2015-04-09 13:52:01 -040097 int o_direct = iocb->ki_flags & IOCB_DIRECT;
Theodore Ts'o8ad28502014-04-21 14:26:57 -040098 int overwrite = 0;
Zheng Liu85630002012-05-28 18:06:51 -040099 ssize_t ret;
Theodore Ts'o7608e612014-04-21 14:26:28 -0400100
Eric Sandeene2b46572008-01-28 23:58:27 -0500101 /*
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400102 * Unaligned direct AIO must be serialized; see comment above
103 * In the case of O_APPEND, assume that we must always serialize
104 */
105 if (o_direct &&
106 ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
107 !is_sync_kiocb(iocb) &&
Al Viro2ba48ce2015-04-09 13:52:01 -0400108 (iocb->ki_flags & IOCB_APPEND ||
Al Viroe768d7f2015-04-07 14:48:22 -0400109 ext4_unaligned_aio(inode, from, iocb->ki_pos))) {
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400110 aio_mutex = ext4_aio_mutex(inode);
111 mutex_lock(aio_mutex);
112 ext4_unwritten_wait(inode);
113 }
114
115 mutex_lock(&inode->i_mutex);
Al Viro3309dd02015-04-09 12:55:47 -0400116 ret = generic_write_checks(iocb, from);
117 if (ret <= 0)
Al Viroe768d7f2015-04-07 14:48:22 -0400118 goto out;
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400119
120 /*
Eric Sandeene2b46572008-01-28 23:58:27 -0500121 * If we have encountered a bitmap-format file, the size limit
122 * is smaller than s_maxbytes, which is for extent-mapped files.
123 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400124 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
Eric Sandeene2b46572008-01-28 23:58:27 -0500125 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Eric Sandeene2b46572008-01-28 23:58:27 -0500126
Al Viro3309dd02015-04-09 12:55:47 -0400127 if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) {
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400128 ret = -EFBIG;
Al Viroe768d7f2015-04-07 14:48:22 -0400129 goto out;
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400130 }
Al Viro3309dd02015-04-09 12:55:47 -0400131 iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
Eric Sandeene2b46572008-01-28 23:58:27 -0500132 }
133
Dmitry Monakhova41537e2014-10-30 10:53:16 -0400134 iocb->private = &overwrite;
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400135 if (o_direct) {
Al Viro3309dd02015-04-09 12:55:47 -0400136 size_t length = iov_iter_count(from);
137 loff_t pos = iocb->ki_pos;
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400138 blk_start_plug(&plug);
139
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400140 /* check whether we do a DIO overwrite or not */
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400141 if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400142 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
143 struct ext4_map_blocks map;
144 unsigned int blkbits = inode->i_blkbits;
145 int err, len;
146
147 map.m_lblk = pos >> blkbits;
148 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
149 - map.m_lblk;
150 len = map.m_len;
151
152 err = ext4_map_blocks(NULL, inode, &map, 0);
153 /*
154 * 'err==len' means that all of blocks has
155 * been preallocated no matter they are
156 * initialized or not. For excluding
157 * unwritten extents, we need to check
158 * m_flags. There are two conditions that
159 * indicate for initialized extents. 1) If we
160 * hit extent cache, EXT4_MAP_MAPPED flag is
161 * returned; 2) If we do a real lookup,
162 * non-flags are returned. So we should check
163 * these two conditions.
164 */
165 if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
166 overwrite = 1;
167 }
Theodore Ts'of5ccfe12014-04-21 14:37:52 -0400168 }
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400169
Al Viro9b884162014-04-17 16:09:22 -0400170 ret = __generic_file_write_iter(iocb, from);
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400171 mutex_unlock(&inode->i_mutex);
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400172
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400173 if (ret > 0) {
174 ssize_t err;
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400175
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400176 err = generic_write_sync(file, iocb->ki_pos - ret, ret);
177 if (err < 0)
178 ret = err;
179 }
180 if (o_direct)
Theodore Ts'o8ad28502014-04-21 14:26:57 -0400181 blk_finish_plug(&plug);
182
Al Viroe768d7f2015-04-07 14:48:22 -0400183 if (aio_mutex)
184 mutex_unlock(aio_mutex);
185 return ret;
186
187out:
188 mutex_unlock(&inode->i_mutex);
Theodore Ts'o7ed07ba2014-04-21 14:36:30 -0400189 if (aio_mutex)
190 mutex_unlock(aio_mutex);
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500191 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700192}
193
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800194#ifdef CONFIG_FS_DAX
195static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
196{
197 return dax_fault(vma, vmf, ext4_get_block);
198 /* Is this the right get_block? */
199}
200
201static int ext4_dax_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
202{
203 return dax_mkwrite(vma, vmf, ext4_get_block);
204}
205
206static const struct vm_operations_struct ext4_dax_vm_ops = {
207 .fault = ext4_dax_fault,
208 .page_mkwrite = ext4_dax_mkwrite,
Boaz Harrosh0e3b2102015-04-15 16:15:14 -0700209 .pfn_mkwrite = dax_pfn_mkwrite,
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800210};
211#else
212#define ext4_dax_vm_ops ext4_file_vm_ops
213#endif
214
Alexey Dobriyanf0f37e2f2009-09-27 22:29:37 +0400215static const struct vm_operations_struct ext4_file_vm_ops = {
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400216 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -0700217 .map_pages = filemap_map_pages,
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400218 .page_mkwrite = ext4_page_mkwrite,
219};
220
221static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
222{
Michael Halcrowc9c74292015-04-12 00:56:10 -0400223 struct inode *inode = file->f_mapping->host;
224
225 if (ext4_encrypted_inode(inode)) {
226 int err = ext4_generate_encryption_key(inode);
227 if (err)
228 return 0;
229 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400230 file_accessed(file);
Ross Zwisler923ae0f2015-02-16 15:59:38 -0800231 if (IS_DAX(file_inode(file))) {
232 vma->vm_ops = &ext4_dax_vm_ops;
233 vma->vm_flags |= VM_MIXEDMAP;
234 } else {
235 vma->vm_ops = &ext4_file_vm_ops;
236 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400237 return 0;
238}
239
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400240static int ext4_file_open(struct inode * inode, struct file * filp)
241{
242 struct super_block *sb = inode->i_sb;
243 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
244 struct vfsmount *mnt = filp->f_path.mnt;
245 struct path path;
246 char buf[64], *cp;
Michael Halcrowc9c74292015-04-12 00:56:10 -0400247 int ret;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400248
249 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
250 !(sb->s_flags & MS_RDONLY))) {
251 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
252 /*
253 * Sample where the filesystem has been mounted and
254 * store it in the superblock for sysadmin convenience
255 * when trying to sort through large numbers of block
256 * devices or filesystem images.
257 */
258 memset(buf, 0, sizeof(buf));
Al Viro38991672010-01-23 20:10:29 -0500259 path.mnt = mnt;
260 path.dentry = mnt->mnt_root;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400261 cp = d_path(&path, buf, sizeof(buf));
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400262 if (!IS_ERR(cp)) {
Jan Kara044ce472012-07-22 20:31:31 -0400263 handle_t *handle;
264 int err;
265
Theodore Ts'o9924a922013-02-08 21:59:22 -0500266 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
Jan Kara044ce472012-07-22 20:31:31 -0400267 if (IS_ERR(handle))
268 return PTR_ERR(handle);
liang xie5d601252014-05-12 22:06:43 -0400269 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
Jan Kara044ce472012-07-22 20:31:31 -0400270 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
271 if (err) {
272 ext4_journal_stop(handle);
273 return err;
274 }
Darrick J. Wongcf803902011-10-25 09:18:41 -0400275 strlcpy(sbi->s_es->s_last_mounted, cp,
276 sizeof(sbi->s_es->s_last_mounted));
Jan Kara044ce472012-07-22 20:31:31 -0400277 ext4_handle_dirty_super(handle, sb);
278 ext4_journal_stop(handle);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400279 }
280 }
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500281 /*
282 * Set up the jbd2_inode if we are opening the inode for
283 * writing and the journal is present
284 */
Jan Karaa3612932013-08-16 21:19:41 -0400285 if (filp->f_mode & FMODE_WRITE) {
Michael Halcrowc9c74292015-04-12 00:56:10 -0400286 ret = ext4_inode_attach_jinode(inode);
Jan Karaa3612932013-08-16 21:19:41 -0400287 if (ret < 0)
288 return ret;
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500289 }
Michael Halcrowc9c74292015-04-12 00:56:10 -0400290 ret = dquot_file_open(inode, filp);
291 if (!ret && ext4_encrypted_inode(inode)) {
292 ret = ext4_generate_encryption_key(inode);
293 if (ret)
294 ret = -EACCES;
295 }
296 return ret;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400297}
298
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400299/*
Zheng Liuc8c0df22012-11-08 21:57:40 -0500300 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
301 * file rather than ext4_ext_walk_space() because we can introduce
302 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
303 * function. When extent status tree has been fully implemented, it will
304 * track all extent status for a file and we can directly use it to
305 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
306 */
307
308/*
309 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
310 * lookup page cache to check whether or not there has some data between
311 * [startoff, endoff] because, if this range contains an unwritten extent,
312 * we determine this extent as a data or a hole according to whether the
313 * page cache has data or not.
314 */
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500315static int ext4_find_unwritten_pgoff(struct inode *inode,
316 int whence,
317 struct ext4_map_blocks *map,
318 loff_t *offset)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500319{
320 struct pagevec pvec;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500321 unsigned int blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500322 pgoff_t index;
323 pgoff_t end;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500324 loff_t endoff;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500325 loff_t startoff;
326 loff_t lastoff;
327 int found = 0;
328
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500329 blkbits = inode->i_sb->s_blocksize_bits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500330 startoff = *offset;
331 lastoff = startoff;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500332 endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500333
334 index = startoff >> PAGE_CACHE_SHIFT;
335 end = endoff >> PAGE_CACHE_SHIFT;
336
337 pagevec_init(&pvec, 0);
338 do {
339 int i, num;
340 unsigned long nr_pages;
341
342 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
343 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
344 (pgoff_t)num);
345 if (nr_pages == 0) {
Andrew Morton965c8e52012-12-17 15:59:39 -0800346 if (whence == SEEK_DATA)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500347 break;
348
Andrew Morton965c8e52012-12-17 15:59:39 -0800349 BUG_ON(whence != SEEK_HOLE);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500350 /*
351 * If this is the first time to go into the loop and
352 * offset is not beyond the end offset, it will be a
353 * hole at this offset
354 */
355 if (lastoff == startoff || lastoff < endoff)
356 found = 1;
357 break;
358 }
359
360 /*
361 * If this is the first time to go into the loop and
362 * offset is smaller than the first page offset, it will be a
363 * hole at this offset.
364 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800365 if (lastoff == startoff && whence == SEEK_HOLE &&
Zheng Liuc8c0df22012-11-08 21:57:40 -0500366 lastoff < page_offset(pvec.pages[0])) {
367 found = 1;
368 break;
369 }
370
371 for (i = 0; i < nr_pages; i++) {
372 struct page *page = pvec.pages[i];
373 struct buffer_head *bh, *head;
374
375 /*
376 * If the current offset is not beyond the end of given
377 * range, it will be a hole.
378 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800379 if (lastoff < endoff && whence == SEEK_HOLE &&
Zheng Liuc8c0df22012-11-08 21:57:40 -0500380 page->index > end) {
381 found = 1;
382 *offset = lastoff;
383 goto out;
384 }
385
386 lock_page(page);
387
388 if (unlikely(page->mapping != inode->i_mapping)) {
389 unlock_page(page);
390 continue;
391 }
392
393 if (!page_has_buffers(page)) {
394 unlock_page(page);
395 continue;
396 }
397
398 if (page_has_buffers(page)) {
399 lastoff = page_offset(page);
400 bh = head = page_buffers(page);
401 do {
402 if (buffer_uptodate(bh) ||
403 buffer_unwritten(bh)) {
Andrew Morton965c8e52012-12-17 15:59:39 -0800404 if (whence == SEEK_DATA)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500405 found = 1;
406 } else {
Andrew Morton965c8e52012-12-17 15:59:39 -0800407 if (whence == SEEK_HOLE)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500408 found = 1;
409 }
410 if (found) {
411 *offset = max_t(loff_t,
412 startoff, lastoff);
413 unlock_page(page);
414 goto out;
415 }
416 lastoff += bh->b_size;
417 bh = bh->b_this_page;
418 } while (bh != head);
419 }
420
421 lastoff = page_offset(page) + PAGE_SIZE;
422 unlock_page(page);
423 }
424
425 /*
426 * The no. of pages is less than our desired, that would be a
427 * hole in there.
428 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800429 if (nr_pages < num && whence == SEEK_HOLE) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500430 found = 1;
431 *offset = lastoff;
432 break;
433 }
434
435 index = pvec.pages[i - 1]->index + 1;
436 pagevec_release(&pvec);
437 } while (index <= end);
438
439out:
440 pagevec_release(&pvec);
441 return found;
442}
443
444/*
445 * ext4_seek_data() retrieves the offset for SEEK_DATA.
446 */
447static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
448{
449 struct inode *inode = file->f_mapping->host;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500450 struct ext4_map_blocks map;
451 struct extent_status es;
452 ext4_lblk_t start, last, end;
453 loff_t dataoff, isize;
454 int blkbits;
455 int ret = 0;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500456
457 mutex_lock(&inode->i_mutex);
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500458
459 isize = i_size_read(inode);
460 if (offset >= isize) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500461 mutex_unlock(&inode->i_mutex);
462 return -ENXIO;
463 }
464
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500465 blkbits = inode->i_sb->s_blocksize_bits;
466 start = offset >> blkbits;
467 last = start;
468 end = isize >> blkbits;
469 dataoff = offset;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500470
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500471 do {
472 map.m_lblk = last;
473 map.m_len = end - last + 1;
474 ret = ext4_map_blocks(NULL, inode, &map, 0);
475 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
476 if (last != start)
477 dataoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500478 break;
479 }
480
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500481 /*
482 * If there is a delay extent at this offset,
483 * it will be as a data.
484 */
485 ext4_es_find_delayed_extent_range(inode, last, last, &es);
486 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
487 if (last != start)
488 dataoff = (loff_t)last << blkbits;
489 break;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500490 }
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500491
492 /*
493 * If there is a unwritten extent at this offset,
494 * it will be as a data or a hole according to page
495 * cache that has data or not.
496 */
497 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
498 int unwritten;
499 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
500 &map, &dataoff);
501 if (unwritten)
502 break;
503 }
504
505 last++;
506 dataoff = (loff_t)last << blkbits;
507 } while (last <= end);
508
Zheng Liuc8c0df22012-11-08 21:57:40 -0500509 mutex_unlock(&inode->i_mutex);
510
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500511 if (dataoff > isize)
512 return -ENXIO;
513
514 return vfs_setpos(file, dataoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500515}
516
517/*
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500518 * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
Zheng Liuc8c0df22012-11-08 21:57:40 -0500519 */
520static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
521{
522 struct inode *inode = file->f_mapping->host;
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500523 struct ext4_map_blocks map;
524 struct extent_status es;
525 ext4_lblk_t start, last, end;
526 loff_t holeoff, isize;
527 int blkbits;
528 int ret = 0;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500529
530 mutex_lock(&inode->i_mutex);
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500531
532 isize = i_size_read(inode);
533 if (offset >= isize) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500534 mutex_unlock(&inode->i_mutex);
535 return -ENXIO;
536 }
537
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500538 blkbits = inode->i_sb->s_blocksize_bits;
539 start = offset >> blkbits;
540 last = start;
541 end = isize >> blkbits;
542 holeoff = offset;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500543
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500544 do {
545 map.m_lblk = last;
546 map.m_len = end - last + 1;
547 ret = ext4_map_blocks(NULL, inode, &map, 0);
548 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
549 last += ret;
550 holeoff = (loff_t)last << blkbits;
551 continue;
552 }
Zheng Liuc8c0df22012-11-08 21:57:40 -0500553
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500554 /*
555 * If there is a delay extent at this offset,
556 * we will skip this extent.
557 */
558 ext4_es_find_delayed_extent_range(inode, last, last, &es);
559 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
560 last = es.es_lblk + es.es_len;
561 holeoff = (loff_t)last << blkbits;
562 continue;
563 }
Zheng Liuc8c0df22012-11-08 21:57:40 -0500564
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500565 /*
566 * If there is a unwritten extent at this offset,
567 * it will be as a data or a hole according to page
568 * cache that has data or not.
569 */
570 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
571 int unwritten;
572 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
573 &map, &holeoff);
574 if (!unwritten) {
575 last += ret;
576 holeoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500577 continue;
578 }
579 }
Zheng Liuc8c0df22012-11-08 21:57:40 -0500580
Theodore Ts'oad7fefb2015-01-02 15:16:00 -0500581 /* find a hole */
582 break;
583 } while (last <= end);
584
585 mutex_unlock(&inode->i_mutex);
586
587 if (holeoff > isize)
588 holeoff = isize;
589
590 return vfs_setpos(file, holeoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500591}
592
593/*
Eric Sandeenec7268c2012-04-30 13:14:03 -0500594 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
595 * by calling generic_file_llseek_size() with the appropriate maxbytes
596 * value for each.
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400597 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800598loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400599{
600 struct inode *inode = file->f_mapping->host;
601 loff_t maxbytes;
602
603 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
604 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
605 else
606 maxbytes = inode->i_sb->s_maxbytes;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400607
Andrew Morton965c8e52012-12-17 15:59:39 -0800608 switch (whence) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500609 case SEEK_SET:
610 case SEEK_CUR:
611 case SEEK_END:
Andrew Morton965c8e52012-12-17 15:59:39 -0800612 return generic_file_llseek_size(file, offset, whence,
Zheng Liuc8c0df22012-11-08 21:57:40 -0500613 maxbytes, i_size_read(inode));
614 case SEEK_DATA:
615 return ext4_seek_data(file, offset, maxbytes);
616 case SEEK_HOLE:
617 return ext4_seek_hole(file, offset, maxbytes);
618 }
619
620 return -EINVAL;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400621}
622
Mingming Cao617ba132006-10-11 01:20:53 -0700623const struct file_operations ext4_file_operations = {
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400624 .llseek = ext4_llseek,
Al Viroaad4f8b2014-04-02 14:33:16 -0400625 .read_iter = generic_file_read_iter,
Al Viro9b884162014-04-17 16:09:22 -0400626 .write_iter = ext4_file_write_iter,
Andi Kleen5cdd7b22008-04-29 22:03:54 -0400627 .unlocked_ioctl = ext4_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700628#ifdef CONFIG_COMPAT
Mingming Cao617ba132006-10-11 01:20:53 -0700629 .compat_ioctl = ext4_compat_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700630#endif
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400631 .mmap = ext4_file_mmap,
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400632 .open = ext4_file_open,
Mingming Cao617ba132006-10-11 01:20:53 -0700633 .release = ext4_release_file,
634 .fsync = ext4_sync_file,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700635 .splice_read = generic_file_splice_read,
Al Viro8d020762014-04-05 04:27:08 -0400636 .splice_write = iter_file_splice_write,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100637 .fallocate = ext4_fallocate,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700638};
639
Arjan van de Ven754661f2007-02-12 00:55:38 -0800640const struct inode_operations ext4_file_inode_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -0700641 .setattr = ext4_setattr,
Mingming Cao3e3398a2008-07-11 19:27:31 -0400642 .getattr = ext4_getattr,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700643 .setxattr = generic_setxattr,
644 .getxattr = generic_getxattr,
Mingming Cao617ba132006-10-11 01:20:53 -0700645 .listxattr = ext4_listxattr,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700646 .removexattr = generic_removexattr,
Christoph Hellwig4e34e712011-07-23 17:37:31 +0200647 .get_acl = ext4_get_acl,
Christoph Hellwig64e178a2013-12-20 05:16:44 -0800648 .set_acl = ext4_set_acl,
Eric Sandeen6873fa02008-10-07 00:46:36 -0400649 .fiemap = ext4_fiemap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700650};
651