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/aio.h>
27 #include <linux/quotaops.h>
28 #include <linux/pagevec.h>
30 #include "ext4_jbd2.h"
35 * Called when an inode is released. Note that this is different
36 * from ext4_file_open: open gets called at every open, but release
37 * gets called only when /all/ the files are closed.
39 static int ext4_release_file(struct inode
*inode
, struct file
*filp
)
41 if (ext4_test_inode_state(inode
, EXT4_STATE_DA_ALLOC_CLOSE
)) {
42 ext4_alloc_da_blocks(inode
);
43 ext4_clear_inode_state(inode
, EXT4_STATE_DA_ALLOC_CLOSE
);
45 /* if we are the last writer on the inode, drop the block reservation */
46 if ((filp
->f_mode
& FMODE_WRITE
) &&
47 (atomic_read(&inode
->i_writecount
) == 1) &&
48 !EXT4_I(inode
)->i_reserved_data_blocks
)
50 down_write(&EXT4_I(inode
)->i_data_sem
);
51 ext4_discard_preallocations(inode
);
52 up_write(&EXT4_I(inode
)->i_data_sem
);
54 if (is_dx(inode
) && filp
->private_data
)
55 ext4_htree_free_dir_info(filp
->private_data
);
60 static void ext4_unwritten_wait(struct inode
*inode
)
62 wait_queue_head_t
*wq
= ext4_ioend_wq(inode
);
64 wait_event(*wq
, (atomic_read(&EXT4_I(inode
)->i_unwritten
) == 0));
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.
77 ext4_unaligned_aio(struct inode
*inode
, struct iov_iter
*from
, loff_t pos
)
79 struct super_block
*sb
= inode
->i_sb
;
80 int blockmask
= sb
->s_blocksize
- 1;
82 if (pos
>= i_size_read(inode
))
85 if ((pos
| iov_iter_alignment(from
)) & blockmask
)
92 ext4_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
94 struct file
*file
= iocb
->ki_filp
;
95 struct inode
*inode
= file_inode(iocb
->ki_filp
);
96 struct mutex
*aio_mutex
= NULL
;
98 int o_direct
= file
->f_flags
& O_DIRECT
;
100 size_t length
= iov_iter_count(from
);
102 loff_t pos
= iocb
->ki_pos
;
105 * Unaligned direct AIO must be serialized; see comment above
106 * In the case of O_APPEND, assume that we must always serialize
109 ext4_test_inode_flag(inode
, EXT4_INODE_EXTENTS
) &&
110 !is_sync_kiocb(iocb
) &&
111 (file
->f_flags
& O_APPEND
||
112 ext4_unaligned_aio(inode
, from
, pos
))) {
113 aio_mutex
= ext4_aio_mutex(inode
);
114 mutex_lock(aio_mutex
);
115 ext4_unwritten_wait(inode
);
118 mutex_lock(&inode
->i_mutex
);
119 if (file
->f_flags
& O_APPEND
)
120 iocb
->ki_pos
= pos
= i_size_read(inode
);
123 * If we have encountered a bitmap-format file, the size limit
124 * is smaller than s_maxbytes, which is for extent-mapped files.
126 if (!(ext4_test_inode_flag(inode
, EXT4_INODE_EXTENTS
))) {
127 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
129 if ((pos
> sbi
->s_bitmap_maxbytes
) ||
130 (pos
== sbi
->s_bitmap_maxbytes
&& length
> 0)) {
131 mutex_unlock(&inode
->i_mutex
);
136 if (pos
+ length
> sbi
->s_bitmap_maxbytes
)
137 iov_iter_truncate(from
, sbi
->s_bitmap_maxbytes
- pos
);
140 iocb
->private = &overwrite
;
142 blk_start_plug(&plug
);
145 /* check whether we do a DIO overwrite or not */
146 if (ext4_should_dioread_nolock(inode
) && !aio_mutex
&&
147 !file
->f_mapping
->nrpages
&& pos
+ length
<= i_size_read(inode
)) {
148 struct ext4_map_blocks map
;
149 unsigned int blkbits
= inode
->i_blkbits
;
152 map
.m_lblk
= pos
>> blkbits
;
153 map
.m_len
= (EXT4_BLOCK_ALIGN(pos
+ length
, blkbits
) >> blkbits
)
157 err
= ext4_map_blocks(NULL
, inode
, &map
, 0);
159 * 'err==len' means that all of blocks has
160 * been preallocated no matter they are
161 * initialized or not. For excluding
162 * unwritten extents, we need to check
163 * m_flags. There are two conditions that
164 * indicate for initialized extents. 1) If we
165 * hit extent cache, EXT4_MAP_MAPPED flag is
166 * returned; 2) If we do a real lookup,
167 * non-flags are returned. So we should check
168 * these two conditions.
170 if (err
== len
&& (map
.m_flags
& EXT4_MAP_MAPPED
))
175 ret
= __generic_file_write_iter(iocb
, from
);
176 mutex_unlock(&inode
->i_mutex
);
181 err
= generic_write_sync(file
, iocb
->ki_pos
- ret
, ret
);
186 blk_finish_plug(&plug
);
190 mutex_unlock(aio_mutex
);
194 static const struct vm_operations_struct ext4_file_vm_ops
= {
195 .fault
= filemap_fault
,
196 .map_pages
= filemap_map_pages
,
197 .page_mkwrite
= ext4_page_mkwrite
,
198 .remap_pages
= generic_file_remap_pages
,
201 static int ext4_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
204 vma
->vm_ops
= &ext4_file_vm_ops
;
208 static int ext4_file_open(struct inode
* inode
, struct file
* filp
)
210 struct super_block
*sb
= inode
->i_sb
;
211 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
212 struct vfsmount
*mnt
= filp
->f_path
.mnt
;
216 if (unlikely(!(sbi
->s_mount_flags
& EXT4_MF_MNTDIR_SAMPLED
) &&
217 !(sb
->s_flags
& MS_RDONLY
))) {
218 sbi
->s_mount_flags
|= EXT4_MF_MNTDIR_SAMPLED
;
220 * Sample where the filesystem has been mounted and
221 * store it in the superblock for sysadmin convenience
222 * when trying to sort through large numbers of block
223 * devices or filesystem images.
225 memset(buf
, 0, sizeof(buf
));
227 path
.dentry
= mnt
->mnt_root
;
228 cp
= d_path(&path
, buf
, sizeof(buf
));
233 handle
= ext4_journal_start_sb(sb
, EXT4_HT_MISC
, 1);
235 return PTR_ERR(handle
);
236 BUFFER_TRACE(sbi
->s_sbh
, "get_write_access");
237 err
= ext4_journal_get_write_access(handle
, sbi
->s_sbh
);
239 ext4_journal_stop(handle
);
242 strlcpy(sbi
->s_es
->s_last_mounted
, cp
,
243 sizeof(sbi
->s_es
->s_last_mounted
));
244 ext4_handle_dirty_super(handle
, sb
);
245 ext4_journal_stop(handle
);
249 * Set up the jbd2_inode if we are opening the inode for
250 * writing and the journal is present
252 if (filp
->f_mode
& FMODE_WRITE
) {
253 int ret
= ext4_inode_attach_jinode(inode
);
257 return dquot_file_open(inode
, filp
);
261 * Here we use ext4_map_blocks() to get a block mapping for a extent-based
262 * file rather than ext4_ext_walk_space() because we can introduce
263 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same
264 * function. When extent status tree has been fully implemented, it will
265 * track all extent status for a file and we can directly use it to
266 * retrieve the offset for SEEK_DATA/SEEK_HOLE.
270 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to
271 * lookup page cache to check whether or not there has some data between
272 * [startoff, endoff] because, if this range contains an unwritten extent,
273 * we determine this extent as a data or a hole according to whether the
274 * page cache has data or not.
276 static int ext4_find_unwritten_pgoff(struct inode
*inode
, int whence
,
277 loff_t endoff
, loff_t
*offset
)
290 index
= startoff
>> PAGE_CACHE_SHIFT
;
291 end
= endoff
>> PAGE_CACHE_SHIFT
;
293 pagevec_init(&pvec
, 0);
296 unsigned long nr_pages
;
298 num
= min_t(pgoff_t
, end
- index
, PAGEVEC_SIZE
);
299 nr_pages
= pagevec_lookup(&pvec
, inode
->i_mapping
, index
,
302 if (whence
== SEEK_DATA
)
305 BUG_ON(whence
!= SEEK_HOLE
);
307 * If this is the first time to go into the loop and
308 * offset is not beyond the end offset, it will be a
309 * hole at this offset
311 if (lastoff
== startoff
|| lastoff
< endoff
)
317 * If this is the first time to go into the loop and
318 * offset is smaller than the first page offset, it will be a
319 * hole at this offset.
321 if (lastoff
== startoff
&& whence
== SEEK_HOLE
&&
322 lastoff
< page_offset(pvec
.pages
[0])) {
327 for (i
= 0; i
< nr_pages
; i
++) {
328 struct page
*page
= pvec
.pages
[i
];
329 struct buffer_head
*bh
, *head
;
332 * If the current offset is not beyond the end of given
333 * range, it will be a hole.
335 if (lastoff
< endoff
&& whence
== SEEK_HOLE
&&
344 if (unlikely(page
->mapping
!= inode
->i_mapping
)) {
349 if (!page_has_buffers(page
)) {
354 if (page_has_buffers(page
)) {
355 lastoff
= page_offset(page
);
356 bh
= head
= page_buffers(page
);
358 if (buffer_uptodate(bh
) ||
359 buffer_unwritten(bh
)) {
360 if (whence
== SEEK_DATA
)
363 if (whence
== SEEK_HOLE
)
367 *offset
= max_t(loff_t
,
372 lastoff
+= bh
->b_size
;
373 bh
= bh
->b_this_page
;
374 } while (bh
!= head
);
377 lastoff
= page_offset(page
) + PAGE_SIZE
;
382 * The no. of pages is less than our desired, that would be a
385 if (nr_pages
< num
&& whence
== SEEK_HOLE
) {
391 index
= pvec
.pages
[i
- 1]->index
+ 1;
392 pagevec_release(&pvec
);
393 } while (index
<= end
);
396 pagevec_release(&pvec
);
401 * ext4_seek_data() retrieves the offset for SEEK_DATA.
403 static loff_t
ext4_seek_data(struct file
*file
, loff_t offset
, loff_t maxsize
)
405 struct inode
*inode
= file
->f_mapping
->host
;
406 struct fiemap_extent_info fie
;
407 struct fiemap_extent ext
[2];
411 mutex_lock(&inode
->i_mutex
);
412 if (offset
>= inode
->i_size
) {
413 mutex_unlock(&inode
->i_mutex
);
417 fie
.fi_extents_max
= 2;
418 fie
.fi_extents_start
= (struct fiemap_extent __user
*) &ext
;
420 mm_segment_t old_fs
= get_fs();
422 fie
.fi_extents_mapped
= 0;
423 memset(ext
, 0, sizeof(*ext
) * fie
.fi_extents_max
);
426 ret
= ext4_fiemap(inode
, &fie
, offset
, maxsize
- offset
);
431 /* No extents found, EOF */
432 if (!fie
.fi_extents_mapped
) {
436 for (i
= 0; i
< fie
.fi_extents_mapped
; i
++) {
437 next
= (loff_t
)(ext
[i
].fe_length
+ ext
[i
].fe_logical
);
439 if (offset
< (loff_t
)ext
[i
].fe_logical
)
440 offset
= (loff_t
)ext
[i
].fe_logical
;
442 * If extent is not unwritten, then it contains valid
443 * data, mapped or delayed.
445 if (!(ext
[i
].fe_flags
& FIEMAP_EXTENT_UNWRITTEN
))
449 * If there is a unwritten extent at this offset,
450 * it will be as a data or a hole according to page
451 * cache that has data or not.
453 if (ext4_find_unwritten_pgoff(inode
, SEEK_DATA
,
457 if (ext
[i
].fe_flags
& FIEMAP_EXTENT_LAST
) {
464 if (offset
> inode
->i_size
)
465 offset
= inode
->i_size
;
467 mutex_unlock(&inode
->i_mutex
);
471 return vfs_setpos(file
, offset
, maxsize
);
475 * ext4_seek_hole() retrieves the offset for SEEK_HOLE
477 static loff_t
ext4_seek_hole(struct file
*file
, loff_t offset
, loff_t maxsize
)
479 struct inode
*inode
= file
->f_mapping
->host
;
480 struct fiemap_extent_info fie
;
481 struct fiemap_extent ext
[2];
485 mutex_lock(&inode
->i_mutex
);
486 if (offset
>= inode
->i_size
) {
487 mutex_unlock(&inode
->i_mutex
);
492 fie
.fi_extents_max
= 2;
493 fie
.fi_extents_start
= (struct fiemap_extent __user
*)&ext
;
495 mm_segment_t old_fs
= get_fs();
497 fie
.fi_extents_mapped
= 0;
498 memset(ext
, 0, sizeof(*ext
));
501 ret
= ext4_fiemap(inode
, &fie
, offset
, maxsize
- offset
);
506 /* No extents found */
507 if (!fie
.fi_extents_mapped
)
510 for (i
= 0; i
< fie
.fi_extents_mapped
; i
++) {
511 next
= (loff_t
)(ext
[i
].fe_logical
+ ext
[i
].fe_length
);
513 * If extent is not unwritten, then it contains valid
514 * data, mapped or delayed.
516 if (!(ext
[i
].fe_flags
& FIEMAP_EXTENT_UNWRITTEN
)) {
517 if (offset
< (loff_t
)ext
[i
].fe_logical
)
523 * If there is a unwritten extent at this offset,
524 * it will be as a data or a hole according to page
525 * cache that has data or not.
527 if (ext4_find_unwritten_pgoff(inode
, SEEK_HOLE
,
532 if (ext
[i
].fe_flags
& FIEMAP_EXTENT_LAST
)
536 if (offset
> inode
->i_size
)
537 offset
= inode
->i_size
;
539 mutex_unlock(&inode
->i_mutex
);
543 return vfs_setpos(file
, offset
, maxsize
);
547 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
548 * by calling generic_file_llseek_size() with the appropriate maxbytes
551 loff_t
ext4_llseek(struct file
*file
, loff_t offset
, int whence
)
553 struct inode
*inode
= file
->f_mapping
->host
;
556 if (!(ext4_test_inode_flag(inode
, EXT4_INODE_EXTENTS
)))
557 maxbytes
= EXT4_SB(inode
->i_sb
)->s_bitmap_maxbytes
;
559 maxbytes
= inode
->i_sb
->s_maxbytes
;
565 return generic_file_llseek_size(file
, offset
, whence
,
566 maxbytes
, i_size_read(inode
));
568 return ext4_seek_data(file
, offset
, maxbytes
);
570 return ext4_seek_hole(file
, offset
, maxbytes
);
576 const struct file_operations ext4_file_operations
= {
577 .llseek
= ext4_llseek
,
578 .read
= new_sync_read
,
579 .write
= new_sync_write
,
580 .read_iter
= generic_file_read_iter
,
581 .write_iter
= ext4_file_write_iter
,
582 .unlocked_ioctl
= ext4_ioctl
,
584 .compat_ioctl
= ext4_compat_ioctl
,
586 .mmap
= ext4_file_mmap
,
587 .open
= ext4_file_open
,
588 .release
= ext4_release_file
,
589 .fsync
= ext4_sync_file
,
590 .splice_read
= generic_file_splice_read
,
591 .splice_write
= iter_file_splice_write
,
592 .fallocate
= ext4_fallocate
,
595 const struct inode_operations ext4_file_inode_operations
= {
596 .setattr
= ext4_setattr
,
597 .getattr
= ext4_getattr
,
598 .setxattr
= generic_setxattr
,
599 .getxattr
= generic_getxattr
,
600 .listxattr
= ext4_listxattr
,
601 .removexattr
= generic_removexattr
,
602 .get_acl
= ext4_get_acl
,
603 .set_acl
= ext4_set_acl
,
604 .fiemap
= ext4_fiemap
,