blob: 319c9d26279a94fa7039dc2f8730747fe2404697 [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>
Mingming Caodab291a2006-10-11 01:21:01 -070023#include <linux/jbd2.h>
Theodore Ts'obc0b0d62009-06-13 10:09:48 -040024#include <linux/mount.h>
25#include <linux/path.h>
Kent Overstreeta27bb332013-05-07 16:19:08 -070026#include <linux/aio.h>
Christoph Hellwig871a2932010-03-03 09:05:07 -050027#include <linux/quotaops.h>
Zheng Liuc8c0df22012-11-08 21:57:40 -050028#include <linux/pagevec.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
Dmitry Monakhovc2785312012-10-05 11:31:55 -040060void 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
77ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
78 unsigned long nr_segs, loff_t pos)
79{
80 struct super_block *sb = inode->i_sb;
81 int blockmask = sb->s_blocksize - 1;
82 size_t count = iov_length(iov, nr_segs);
83 loff_t final_size = pos + count;
84
85 if (pos >= inode->i_size)
86 return 0;
87
88 if ((pos & blockmask) || (final_size & blockmask))
89 return 1;
90
91 return 0;
92}
93
Dave Kleikampac27a0e2006-10-11 01:20:50 -070094static ssize_t
Zheng Liufbe10492012-07-09 16:29:29 -040095ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
96 unsigned long nr_segs, loff_t pos)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070097{
Zheng Liu4bd809d2012-07-22 20:19:31 -040098 struct file *file = iocb->ki_filp;
99 struct inode *inode = file->f_mapping->host;
100 struct blk_plug plug;
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500101 int unaligned_aio = 0;
Zheng Liu85630002012-05-28 18:06:51 -0400102 ssize_t ret;
Zheng Liu4bd809d2012-07-22 20:19:31 -0400103 int overwrite = 0;
104 size_t length = iov_length(iov, nr_segs);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700105
Zheng Liufbe10492012-07-09 16:29:29 -0400106 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
107 !is_sync_kiocb(iocb))
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500108 unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
Eric Sandeene2b46572008-01-28 23:58:27 -0500109
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500110 /* Unaligned direct AIO must be serialized; see comment above */
111 if (unaligned_aio) {
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500112 mutex_lock(ext4_aio_mutex(inode));
Dmitry Monakhove27f41e2012-09-28 23:24:52 -0400113 ext4_unwritten_wait(inode);
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500114 }
115
Zheng Liu4bd809d2012-07-22 20:19:31 -0400116 BUG_ON(iocb->ki_pos != pos);
117
118 mutex_lock(&inode->i_mutex);
119 blk_start_plug(&plug);
120
121 iocb->private = &overwrite;
122
123 /* check whether we do a DIO overwrite or not */
124 if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
125 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
126 struct ext4_map_blocks map;
127 unsigned int blkbits = inode->i_blkbits;
128 int err, len;
129
130 map.m_lblk = pos >> blkbits;
131 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
132 - map.m_lblk;
133 len = map.m_len;
134
135 err = ext4_map_blocks(NULL, inode, &map, 0);
136 /*
137 * 'err==len' means that all of blocks has been preallocated no
138 * matter they are initialized or not. For excluding
139 * uninitialized extents, we need to check m_flags. There are
140 * two conditions that indicate for initialized extents.
141 * 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
142 * 2) If we do a real lookup, non-flags are returned.
143 * So we should check these two conditions.
144 */
145 if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
146 overwrite = 1;
147 }
148
149 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
150 mutex_unlock(&inode->i_mutex);
151
152 if (ret > 0 || ret == -EIOCBQUEUED) {
153 ssize_t err;
154
155 err = generic_write_sync(file, pos, ret);
156 if (err < 0 && ret > 0)
157 ret = err;
158 }
159 blk_finish_plug(&plug);
Eric Sandeene9e3bce2011-02-12 08:17:34 -0500160
161 if (unaligned_aio)
162 mutex_unlock(ext4_aio_mutex(inode));
163
164 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700165}
166
Zheng Liufbe10492012-07-09 16:29:29 -0400167static ssize_t
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400168ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
169 unsigned long nr_segs, loff_t pos)
170{
Al Viro496ad9a2013-01-23 17:07:38 -0500171 struct inode *inode = file_inode(iocb->ki_filp);
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400172 ssize_t ret;
173
174 /*
175 * If we have encountered a bitmap-format file, the size limit
176 * is smaller than s_maxbytes, which is for extent-mapped files.
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400177 */
178
179 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
180 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500181 size_t length = iov_length(iov, nr_segs);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400182
183 if ((pos > sbi->s_bitmap_maxbytes ||
184 (pos == sbi->s_bitmap_maxbytes && length > 0)))
185 return -EFBIG;
186
187 if (pos + length > sbi->s_bitmap_maxbytes) {
188 nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
189 sbi->s_bitmap_maxbytes - pos);
190 }
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400191 }
192
Zheng Liufbe10492012-07-09 16:29:29 -0400193 if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
194 ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
195 else
196 ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500197
198 return ret;
199}
200
201static const struct vm_operations_struct ext4_file_vm_ops = {
202 .fault = filemap_fault,
203 .page_mkwrite = ext4_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -0700204 .remap_pages = generic_file_remap_pages,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700205};
206
207static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
208{
209 struct address_space *mapping = file->f_mapping;
210
211 if (!mapping->a_ops->readpage)
212 return -ENOEXEC;
213 file_accessed(file);
214 vma->vm_ops = &ext4_file_vm_ops;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700215 return 0;
216}
217
218static int ext4_file_open(struct inode * inode, struct file * filp)
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400219{
220 struct super_block *sb = inode->i_sb;
221 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400222 struct vfsmount *mnt = filp->f_path.mnt;
223 struct path path;
224 char buf[64], *cp;
225
226 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
227 !(sb->s_flags & MS_RDONLY))) {
228 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
229 /*
230 * Sample where the filesystem has been mounted and
231 * store it in the superblock for sysadmin convenience
232 * when trying to sort through large numbers of block
233 * devices or filesystem images.
234 */
235 memset(buf, 0, sizeof(buf));
Al Viro38991672010-01-23 20:10:29 -0500236 path.mnt = mnt;
237 path.dentry = mnt->mnt_root;
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400238 cp = d_path(&path, buf, sizeof(buf));
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400239 if (!IS_ERR(cp)) {
Jan Kara044ce472012-07-22 20:31:31 -0400240 handle_t *handle;
241 int err;
242
Theodore Ts'o9924a922013-02-08 21:59:22 -0500243 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
Jan Kara044ce472012-07-22 20:31:31 -0400244 if (IS_ERR(handle))
245 return PTR_ERR(handle);
246 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
247 if (err) {
248 ext4_journal_stop(handle);
249 return err;
250 }
Darrick J. Wongcf803902011-10-25 09:18:41 -0400251 strlcpy(sbi->s_es->s_last_mounted, cp,
252 sizeof(sbi->s_es->s_last_mounted));
Jan Kara044ce472012-07-22 20:31:31 -0400253 ext4_handle_dirty_super(handle, sb);
254 ext4_journal_stop(handle);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400255 }
256 }
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500257 /*
258 * Set up the jbd2_inode if we are opening the inode for
259 * writing and the journal is present
260 */
Jan Karaa3612932013-08-16 21:19:41 -0400261 if (filp->f_mode & FMODE_WRITE) {
262 int ret = ext4_inode_attach_jinode(inode);
263 if (ret < 0)
264 return ret;
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500265 }
Christoph Hellwig907f4552010-03-03 09:05:06 -0500266 return dquot_file_open(inode, filp);
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400267}
268
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400269/*
Zheng Liuc8c0df22012-11-08 21:57:40 -0500270 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
271 * file rather than ext4_ext_walk_space() because we can introduce
272 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
273 * function. When extent status tree has been fully implemented, it will
274 * track all extent status for a file and we can directly use it to
275 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
276 */
277
278/*
279 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
280 * lookup page cache to check whether or not there has some data between
281 * [startoff, endoff] because, if this range contains an unwritten extent,
282 * we determine this extent as a data or a hole according to whether the
283 * page cache has data or not.
284 */
285static int ext4_find_unwritten_pgoff(struct inode *inode,
Andrew Morton965c8e52012-12-17 15:59:39 -0800286 int whence,
Zheng Liuc8c0df22012-11-08 21:57:40 -0500287 struct ext4_map_blocks *map,
288 loff_t *offset)
289{
290 struct pagevec pvec;
291 unsigned int blkbits;
292 pgoff_t index;
293 pgoff_t end;
294 loff_t endoff;
295 loff_t startoff;
296 loff_t lastoff;
297 int found = 0;
298
299 blkbits = inode->i_sb->s_blocksize_bits;
300 startoff = *offset;
301 lastoff = startoff;
Jan Karae7293fd2013-05-31 19:37:56 -0400302 endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500303
304 index = startoff >> PAGE_CACHE_SHIFT;
305 end = endoff >> PAGE_CACHE_SHIFT;
306
307 pagevec_init(&pvec, 0);
308 do {
309 int i, num;
310 unsigned long nr_pages;
311
312 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
313 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
314 (pgoff_t)num);
315 if (nr_pages == 0) {
Andrew Morton965c8e52012-12-17 15:59:39 -0800316 if (whence == SEEK_DATA)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500317 break;
318
Andrew Morton965c8e52012-12-17 15:59:39 -0800319 BUG_ON(whence != SEEK_HOLE);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500320 /*
321 * If this is the first time to go into the loop and
322 * offset is not beyond the end offset, it will be a
323 * hole at this offset
324 */
325 if (lastoff == startoff || lastoff < endoff)
326 found = 1;
327 break;
328 }
329
330 /*
331 * If this is the first time to go into the loop and
332 * offset is smaller than the first page offset, it will be a
333 * hole at this offset.
334 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800335 if (lastoff == startoff && whence == SEEK_HOLE &&
Zheng Liuc8c0df22012-11-08 21:57:40 -0500336 lastoff < page_offset(pvec.pages[0])) {
337 found = 1;
338 break;
339 }
340
341 for (i = 0; i < nr_pages; i++) {
342 struct page *page = pvec.pages[i];
343 struct buffer_head *bh, *head;
344
345 /*
346 * If the current offset is not beyond the end of given
347 * range, it will be a hole.
348 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800349 if (lastoff < endoff && whence == SEEK_HOLE &&
Zheng Liuc8c0df22012-11-08 21:57:40 -0500350 page->index > end) {
351 found = 1;
352 *offset = lastoff;
353 goto out;
354 }
355
356 lock_page(page);
357
358 if (unlikely(page->mapping != inode->i_mapping)) {
359 unlock_page(page);
360 continue;
361 }
362
363 if (!page_has_buffers(page)) {
364 unlock_page(page);
365 continue;
366 }
367
368 if (page_has_buffers(page)) {
369 lastoff = page_offset(page);
370 bh = head = page_buffers(page);
371 do {
372 if (buffer_uptodate(bh) ||
373 buffer_unwritten(bh)) {
Andrew Morton965c8e52012-12-17 15:59:39 -0800374 if (whence == SEEK_DATA)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500375 found = 1;
376 } else {
Andrew Morton965c8e52012-12-17 15:59:39 -0800377 if (whence == SEEK_HOLE)
Zheng Liuc8c0df22012-11-08 21:57:40 -0500378 found = 1;
379 }
380 if (found) {
381 *offset = max_t(loff_t,
382 startoff, lastoff);
383 unlock_page(page);
384 goto out;
385 }
386 lastoff += bh->b_size;
387 bh = bh->b_this_page;
388 } while (bh != head);
389 }
390
391 lastoff = page_offset(page) + PAGE_SIZE;
392 unlock_page(page);
393 }
394
395 /*
396 * The no. of pages is less than our desired, that would be a
397 * hole in there.
398 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800399 if (nr_pages < num && whence == SEEK_HOLE) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500400 found = 1;
401 *offset = lastoff;
402 break;
403 }
404
405 index = pvec.pages[i - 1]->index + 1;
406 pagevec_release(&pvec);
407 } while (index <= end);
408
409out:
410 pagevec_release(&pvec);
411 return found;
412}
413
414/*
415 * ext4_seek_data() retrieves the offset for SEEK_DATA.
416 */
417static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
418{
419 struct inode *inode = file->f_mapping->host;
420 struct ext4_map_blocks map;
421 struct extent_status es;
422 ext4_lblk_t start, last, end;
423 loff_t dataoff, isize;
424 int blkbits;
425 int ret = 0;
426
427 mutex_lock(&inode->i_mutex);
428
429 isize = i_size_read(inode);
430 if (offset >= isize) {
431 mutex_unlock(&inode->i_mutex);
432 return -ENXIO;
433 }
434
435 blkbits = inode->i_sb->s_blocksize_bits;
436 start = offset >> blkbits;
437 last = start;
438 end = isize >> blkbits;
439 dataoff = offset;
440
441 do {
442 map.m_lblk = last;
443 map.m_len = end - last + 1;
444 ret = ext4_map_blocks(NULL, inode, &map, 0);
445 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
446 if (last != start)
Jan Karae7293fd2013-05-31 19:37:56 -0400447 dataoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500448 break;
449 }
450
451 /*
452 * If there is a delay extent at this offset,
453 * it will be as a data.
454 */
Yan, Zhenge30b5dc2013-05-03 02:15:52 -0400455 ext4_es_find_delayed_extent_range(inode, last, last, &es);
Zheng Liu06b0c882013-02-18 00:26:51 -0500456 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500457 if (last != start)
Jan Karae7293fd2013-05-31 19:37:56 -0400458 dataoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500459 break;
460 }
461
462 /*
463 * If there is a unwritten extent at this offset,
464 * it will be as a data or a hole according to page
465 * cache that has data or not.
466 */
467 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
468 int unwritten;
469 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
470 &map, &dataoff);
471 if (unwritten)
472 break;
473 }
474
475 last++;
Jan Karae7293fd2013-05-31 19:37:56 -0400476 dataoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500477 } while (last <= end);
478
479 mutex_unlock(&inode->i_mutex);
480
481 if (dataoff > isize)
482 return -ENXIO;
483
Jie Liu46a1c2c2013-06-25 12:02:13 +0800484 return vfs_setpos(file, dataoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500485}
486
487/*
488 * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
489 */
490static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
491{
492 struct inode *inode = file->f_mapping->host;
493 struct ext4_map_blocks map;
494 struct extent_status es;
495 ext4_lblk_t start, last, end;
496 loff_t holeoff, isize;
497 int blkbits;
498 int ret = 0;
499
500 mutex_lock(&inode->i_mutex);
501
502 isize = i_size_read(inode);
503 if (offset >= isize) {
504 mutex_unlock(&inode->i_mutex);
505 return -ENXIO;
506 }
507
508 blkbits = inode->i_sb->s_blocksize_bits;
509 start = offset >> blkbits;
510 last = start;
511 end = isize >> blkbits;
512 holeoff = offset;
513
514 do {
515 map.m_lblk = last;
516 map.m_len = end - last + 1;
517 ret = ext4_map_blocks(NULL, inode, &map, 0);
518 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
519 last += ret;
Jan Karae7293fd2013-05-31 19:37:56 -0400520 holeoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500521 continue;
522 }
523
524 /*
525 * If there is a delay extent at this offset,
526 * we will skip this extent.
527 */
Yan, Zhenge30b5dc2013-05-03 02:15:52 -0400528 ext4_es_find_delayed_extent_range(inode, last, last, &es);
Zheng Liu06b0c882013-02-18 00:26:51 -0500529 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) {
530 last = es.es_lblk + es.es_len;
Jan Karae7293fd2013-05-31 19:37:56 -0400531 holeoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500532 continue;
533 }
534
535 /*
536 * If there is a unwritten extent at this offset,
537 * it will be as a data or a hole according to page
538 * cache that has data or not.
539 */
540 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
541 int unwritten;
542 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
543 &map, &holeoff);
544 if (!unwritten) {
545 last += ret;
Jan Karae7293fd2013-05-31 19:37:56 -0400546 holeoff = (loff_t)last << blkbits;
Zheng Liuc8c0df22012-11-08 21:57:40 -0500547 continue;
548 }
549 }
550
551 /* find a hole */
552 break;
553 } while (last <= end);
554
555 mutex_unlock(&inode->i_mutex);
556
557 if (holeoff > isize)
558 holeoff = isize;
559
Jie Liu46a1c2c2013-06-25 12:02:13 +0800560 return vfs_setpos(file, holeoff, maxsize);
Zheng Liuc8c0df22012-11-08 21:57:40 -0500561}
562
563/*
Eric Sandeenec7268c2012-04-30 13:14:03 -0500564 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
565 * by calling generic_file_llseek_size() with the appropriate maxbytes
566 * value for each.
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400567 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800568loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400569{
570 struct inode *inode = file->f_mapping->host;
571 loff_t maxbytes;
572
573 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
574 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
575 else
576 maxbytes = inode->i_sb->s_maxbytes;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400577
Andrew Morton965c8e52012-12-17 15:59:39 -0800578 switch (whence) {
Zheng Liuc8c0df22012-11-08 21:57:40 -0500579 case SEEK_SET:
580 case SEEK_CUR:
581 case SEEK_END:
Andrew Morton965c8e52012-12-17 15:59:39 -0800582 return generic_file_llseek_size(file, offset, whence,
Zheng Liuc8c0df22012-11-08 21:57:40 -0500583 maxbytes, i_size_read(inode));
584 case SEEK_DATA:
585 return ext4_seek_data(file, offset, maxbytes);
586 case SEEK_HOLE:
587 return ext4_seek_hole(file, offset, maxbytes);
588 }
589
590 return -EINVAL;
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400591}
592
Mingming Cao617ba132006-10-11 01:20:53 -0700593const struct file_operations ext4_file_operations = {
Toshiyuki Okajimae0d10bf2010-10-27 21:30:06 -0400594 .llseek = ext4_llseek,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700595 .read = do_sync_read,
596 .write = do_sync_write,
597 .aio_read = generic_file_aio_read,
Mingming Cao617ba132006-10-11 01:20:53 -0700598 .aio_write = ext4_file_write,
Andi Kleen5cdd7b22008-04-29 22:03:54 -0400599 .unlocked_ioctl = ext4_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700600#ifdef CONFIG_COMPAT
Mingming Cao617ba132006-10-11 01:20:53 -0700601 .compat_ioctl = ext4_compat_ioctl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700602#endif
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -0400603 .mmap = ext4_file_mmap,
Theodore Ts'obc0b0d62009-06-13 10:09:48 -0400604 .open = ext4_file_open,
Mingming Cao617ba132006-10-11 01:20:53 -0700605 .release = ext4_release_file,
606 .fsync = ext4_sync_file,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700607 .splice_read = generic_file_splice_read,
608 .splice_write = generic_file_splice_write,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100609 .fallocate = ext4_fallocate,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700610};
611
Arjan van de Ven754661f2007-02-12 00:55:38 -0800612const struct inode_operations ext4_file_inode_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -0700613 .setattr = ext4_setattr,
Mingming Cao3e3398a2008-07-11 19:27:31 -0400614 .getattr = ext4_getattr,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700615 .setxattr = generic_setxattr,
616 .getxattr = generic_getxattr,
Mingming Cao617ba132006-10-11 01:20:53 -0700617 .listxattr = ext4_listxattr,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700618 .removexattr = generic_removexattr,
Christoph Hellwig4e34e712011-07-23 17:37:31 +0200619 .get_acl = ext4_get_acl,
Eric Sandeen6873fa02008-10-07 00:46:36 -0400620 .fiemap = ext4_fiemap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700621};
622