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 * ext4 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>
23 #include <linux/jbd2.h>
24 #include <linux/mount.h>
25 #include <linux/path.h>
26 #include <linux/quotaops.h>
27 #include <linux/pagevec.h>
29 #include "ext4_jbd2.h"
34 * Called when an inode is released. Note that this is different
35 * from ext4_file_open: open gets called at every open, but release
36 * gets called only when /all/ the files are closed.
38 static int ext4_release_file(struct inode *inode, struct file *filp)
40 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
41 ext4_alloc_da_blocks(inode);
42 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
44 /* if we are the last writer on the inode, drop the block reservation */
45 if ((filp->f_mode & FMODE_WRITE) &&
46 (atomic_read(&inode->i_writecount) == 1) &&
47 !EXT4_I(inode)->i_reserved_data_blocks)
49 down_write(&EXT4_I(inode)->i_data_sem);
50 ext4_discard_preallocations(inode);
51 up_write(&EXT4_I(inode)->i_data_sem);
53 if (is_dx(inode) && filp->private_data)
54 ext4_htree_free_dir_info(filp->private_data);
59 void ext4_unwritten_wait(struct inode *inode)
61 wait_queue_head_t *wq = ext4_ioend_wq(inode);
63 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
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.
76 ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
77 unsigned long nr_segs, loff_t pos)
79 struct super_block *sb = inode->i_sb;
80 int blockmask = sb->s_blocksize - 1;
81 size_t count = iov_length(iov, nr_segs);
82 loff_t final_size = pos + count;
84 if (pos >= inode->i_size)
87 if ((pos & blockmask) || (final_size & blockmask))
94 ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
95 unsigned long nr_segs, loff_t pos)
97 struct file *file = iocb->ki_filp;
98 struct inode *inode = file->f_mapping->host;
100 int unaligned_aio = 0;
103 size_t length = iov_length(iov, nr_segs);
105 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
106 !is_sync_kiocb(iocb))
107 unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
109 /* Unaligned direct AIO must be serialized; see comment above */
111 static unsigned long unaligned_warn_time;
113 /* Warn about this once per day */
114 if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
115 ext4_msg(inode->i_sb, KERN_WARNING,
116 "Unaligned AIO/DIO on inode %ld by %s; "
117 "performance will be poor.",
118 inode->i_ino, current->comm);
119 mutex_lock(ext4_aio_mutex(inode));
120 ext4_unwritten_wait(inode);
123 BUG_ON(iocb->ki_pos != pos);
125 mutex_lock(&inode->i_mutex);
126 blk_start_plug(&plug);
128 iocb->private = &overwrite;
130 /* check whether we do a DIO overwrite or not */
131 if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
132 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
133 struct ext4_map_blocks map;
134 unsigned int blkbits = inode->i_blkbits;
137 map.m_lblk = pos >> blkbits;
138 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
142 err = ext4_map_blocks(NULL, inode, &map, 0);
144 * 'err==len' means that all of blocks has been preallocated no
145 * matter they are initialized or not. For excluding
146 * uninitialized extents, we need to check m_flags. There are
147 * two conditions that indicate for initialized extents.
148 * 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
149 * 2) If we do a real lookup, non-flags are returned.
150 * So we should check these two conditions.
152 if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
156 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
157 mutex_unlock(&inode->i_mutex);
159 if (ret > 0 || ret == -EIOCBQUEUED) {
162 err = generic_write_sync(file, pos, ret);
163 if (err < 0 && ret > 0)
166 blk_finish_plug(&plug);
169 mutex_unlock(ext4_aio_mutex(inode));
175 ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
176 unsigned long nr_segs, loff_t pos)
178 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
182 * If we have encountered a bitmap-format file, the size limit
183 * is smaller than s_maxbytes, which is for extent-mapped files.
186 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
187 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
188 size_t length = iov_length(iov, nr_segs);
190 if ((pos > sbi->s_bitmap_maxbytes ||
191 (pos == sbi->s_bitmap_maxbytes && length > 0)))
194 if (pos + length > sbi->s_bitmap_maxbytes) {
195 nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
196 sbi->s_bitmap_maxbytes - pos);
200 if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
201 ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
203 ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
208 static const struct vm_operations_struct ext4_file_vm_ops = {
209 .fault = filemap_fault,
210 .page_mkwrite = ext4_page_mkwrite,
211 .remap_pages = generic_file_remap_pages,
214 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
216 struct address_space *mapping = file->f_mapping;
218 if (!mapping->a_ops->readpage)
221 vma->vm_ops = &ext4_file_vm_ops;
225 static int ext4_file_open(struct inode * inode, struct file * filp)
227 struct super_block *sb = inode->i_sb;
228 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
229 struct ext4_inode_info *ei = EXT4_I(inode);
230 struct vfsmount *mnt = filp->f_path.mnt;
234 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
235 !(sb->s_flags & MS_RDONLY))) {
236 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
238 * Sample where the filesystem has been mounted and
239 * store it in the superblock for sysadmin convenience
240 * when trying to sort through large numbers of block
241 * devices or filesystem images.
243 memset(buf, 0, sizeof(buf));
245 path.dentry = mnt->mnt_root;
246 cp = d_path(&path, buf, sizeof(buf));
251 handle = ext4_journal_start_sb(sb, 1);
253 return PTR_ERR(handle);
254 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
256 ext4_journal_stop(handle);
259 strlcpy(sbi->s_es->s_last_mounted, cp,
260 sizeof(sbi->s_es->s_last_mounted));
261 ext4_handle_dirty_super(handle, sb);
262 ext4_journal_stop(handle);
266 * Set up the jbd2_inode if we are opening the inode for
267 * writing and the journal is present
269 if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {
270 struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);
272 spin_lock(&inode->i_lock);
275 spin_unlock(&inode->i_lock);
279 jbd2_journal_init_jbd_inode(ei->jinode, inode);
282 spin_unlock(&inode->i_lock);
283 if (unlikely(jinode != NULL))
284 jbd2_free_inode(jinode);
286 return dquot_file_open(inode, filp);
290 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
291 * file rather than ext4_ext_walk_space() because we can introduce
292 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
293 * function. When extent status tree has been fully implemented, it will
294 * track all extent status for a file and we can directly use it to
295 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
299 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
300 * lookup page cache to check whether or not there has some data between
301 * [startoff, endoff] because, if this range contains an unwritten extent,
302 * we determine this extent as a data or a hole according to whether the
303 * page cache has data or not.
305 static int ext4_find_unwritten_pgoff(struct inode *inode,
307 struct ext4_map_blocks *map,
311 unsigned int blkbits;
319 blkbits = inode->i_sb->s_blocksize_bits;
322 endoff = (map->m_lblk + map->m_len) << blkbits;
324 index = startoff >> PAGE_CACHE_SHIFT;
325 end = endoff >> PAGE_CACHE_SHIFT;
327 pagevec_init(&pvec, 0);
330 unsigned long nr_pages;
332 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
333 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
336 if (whence == SEEK_DATA)
339 BUG_ON(whence != SEEK_HOLE);
341 * If this is the first time to go into the loop and
342 * offset is not beyond the end offset, it will be a
343 * hole at this offset
345 if (lastoff == startoff || lastoff < endoff)
351 * If this is the first time to go into the loop and
352 * offset is smaller than the first page offset, it will be a
353 * hole at this offset.
355 if (lastoff == startoff && whence == SEEK_HOLE &&
356 lastoff < page_offset(pvec.pages[0])) {
361 for (i = 0; i < nr_pages; i++) {
362 struct page *page = pvec.pages[i];
363 struct buffer_head *bh, *head;
366 * If the current offset is not beyond the end of given
367 * range, it will be a hole.
369 if (lastoff < endoff && whence == SEEK_HOLE &&
378 if (unlikely(page->mapping != inode->i_mapping)) {
383 if (!page_has_buffers(page)) {
388 if (page_has_buffers(page)) {
389 lastoff = page_offset(page);
390 bh = head = page_buffers(page);
392 if (buffer_uptodate(bh) ||
393 buffer_unwritten(bh)) {
394 if (whence == SEEK_DATA)
397 if (whence == SEEK_HOLE)
401 *offset = max_t(loff_t,
406 lastoff += bh->b_size;
407 bh = bh->b_this_page;
408 } while (bh != head);
411 lastoff = page_offset(page) + PAGE_SIZE;
416 * The no. of pages is less than our desired, that would be a
419 if (nr_pages < num && whence == SEEK_HOLE) {
425 index = pvec.pages[i - 1]->index + 1;
426 pagevec_release(&pvec);
427 } while (index <= end);
430 pagevec_release(&pvec);
435 * ext4_seek_data() retrieves the offset for SEEK_DATA.
437 static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
439 struct inode *inode = file->f_mapping->host;
440 struct ext4_map_blocks map;
441 struct extent_status es;
442 ext4_lblk_t start, last, end;
443 loff_t dataoff, isize;
447 mutex_lock(&inode->i_mutex);
449 isize = i_size_read(inode);
450 if (offset >= isize) {
451 mutex_unlock(&inode->i_mutex);
455 blkbits = inode->i_sb->s_blocksize_bits;
456 start = offset >> blkbits;
458 end = isize >> blkbits;
463 map.m_len = end - last + 1;
464 ret = ext4_map_blocks(NULL, inode, &map, 0);
465 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
467 dataoff = last << blkbits;
472 * If there is a delay extent at this offset,
473 * it will be as a data.
476 (void)ext4_es_find_extent(inode, &es);
477 if (last >= es.start &&
478 last < es.start + es.len) {
480 dataoff = last << blkbits;
485 * If there is a unwritten extent at this offset,
486 * it will be as a data or a hole according to page
487 * cache that has data or not.
489 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
491 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA,
498 dataoff = last << blkbits;
499 } while (last <= end);
501 mutex_unlock(&inode->i_mutex);
506 if (dataoff < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
508 if (dataoff > maxsize)
511 if (dataoff != file->f_pos) {
512 file->f_pos = dataoff;
520 * ext4_seek_hole() retrieves the offset for SEEK_HOLE.
522 static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
524 struct inode *inode = file->f_mapping->host;
525 struct ext4_map_blocks map;
526 struct extent_status es;
527 ext4_lblk_t start, last, end;
528 loff_t holeoff, isize;
532 mutex_lock(&inode->i_mutex);
534 isize = i_size_read(inode);
535 if (offset >= isize) {
536 mutex_unlock(&inode->i_mutex);
540 blkbits = inode->i_sb->s_blocksize_bits;
541 start = offset >> blkbits;
543 end = isize >> blkbits;
548 map.m_len = end - last + 1;
549 ret = ext4_map_blocks(NULL, inode, &map, 0);
550 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) {
552 holeoff = last << blkbits;
557 * If there is a delay extent at this offset,
558 * we will skip this extent.
561 (void)ext4_es_find_extent(inode, &es);
562 if (last >= es.start &&
563 last < es.start + es.len) {
564 last = es.start + es.len;
565 holeoff = last << blkbits;
570 * If there is a unwritten extent at this offset,
571 * it will be as a data or a hole according to page
572 * cache that has data or not.
574 if (map.m_flags & EXT4_MAP_UNWRITTEN) {
576 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE,
580 holeoff = last << blkbits;
587 } while (last <= end);
589 mutex_unlock(&inode->i_mutex);
594 if (holeoff < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
596 if (holeoff > maxsize)
599 if (holeoff != file->f_pos) {
600 file->f_pos = holeoff;
608 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
609 * by calling generic_file_llseek_size() with the appropriate maxbytes
612 loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
614 struct inode *inode = file->f_mapping->host;
617 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
618 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
620 maxbytes = inode->i_sb->s_maxbytes;
626 return generic_file_llseek_size(file, offset, whence,
627 maxbytes, i_size_read(inode));
629 return ext4_seek_data(file, offset, maxbytes);
631 return ext4_seek_hole(file, offset, maxbytes);
637 const struct file_operations ext4_file_operations = {
638 .llseek = ext4_llseek,
639 .read = do_sync_read,
640 .write = do_sync_write,
641 .aio_read = generic_file_aio_read,
642 .aio_write = ext4_file_write,
643 .unlocked_ioctl = ext4_ioctl,
645 .compat_ioctl = ext4_compat_ioctl,
647 .mmap = ext4_file_mmap,
648 .open = ext4_file_open,
649 .release = ext4_release_file,
650 .fsync = ext4_sync_file,
651 .splice_read = generic_file_splice_read,
652 .splice_write = generic_file_splice_write,
653 .fallocate = ext4_fallocate,
656 const struct inode_operations ext4_file_inode_operations = {
657 .setattr = ext4_setattr,
658 .getattr = ext4_getattr,
659 .setxattr = generic_setxattr,
660 .getxattr = generic_getxattr,
661 .listxattr = ext4_listxattr,
662 .removexattr = generic_removexattr,
663 .get_acl = ext4_get_acl,
664 .fiemap = ext4_fiemap,