Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/ext4/file.c
4 : : *
5 : : * Copyright (C) 1992, 1993, 1994, 1995
6 : : * Remy Card (card@masi.ibp.fr)
7 : : * Laboratoire MASI - Institut Blaise Pascal
8 : : * Universite Pierre et Marie Curie (Paris VI)
9 : : *
10 : : * from
11 : : *
12 : : * linux/fs/minix/file.c
13 : : *
14 : : * Copyright (C) 1991, 1992 Linus Torvalds
15 : : *
16 : : * ext4 fs regular file handling primitives
17 : : *
18 : : * 64-bit file support on 64-bit platforms by Jakub Jelinek
19 : : * (jj@sunsite.ms.mff.cuni.cz)
20 : : */
21 : :
22 : : #include <linux/time.h>
23 : : #include <linux/fs.h>
24 : : #include <linux/iomap.h>
25 : : #include <linux/mount.h>
26 : : #include <linux/path.h>
27 : : #include <linux/dax.h>
28 : : #include <linux/quotaops.h>
29 : : #include <linux/pagevec.h>
30 : : #include <linux/uio.h>
31 : : #include <linux/mman.h>
32 : : #include <linux/backing-dev.h>
33 : : #include "ext4.h"
34 : : #include "ext4_jbd2.h"
35 : : #include "xattr.h"
36 : : #include "acl.h"
37 : : #include "truncate.h"
38 : :
39 : 0 : static bool ext4_dio_supported(struct inode *inode)
40 : : {
41 : 0 : if (IS_ENABLED(CONFIG_FS_ENCRYPTION) && IS_ENCRYPTED(inode))
42 : : return false;
43 : 0 : if (fsverity_active(inode))
44 : : return false;
45 [ # # ]: 0 : if (ext4_should_journal_data(inode))
46 : : return false;
47 : 0 : if (ext4_has_inline_data(inode))
48 : 0 : return false;
49 : : return true;
50 : : }
51 : :
52 : 0 : static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
53 : : {
54 : 0 : ssize_t ret;
55 [ # # ]: 0 : struct inode *inode = file_inode(iocb->ki_filp);
56 : :
57 [ # # ]: 0 : if (iocb->ki_flags & IOCB_NOWAIT) {
58 [ # # ]: 0 : if (!inode_trylock_shared(inode))
59 : : return -EAGAIN;
60 : : } else {
61 : 0 : inode_lock_shared(inode);
62 : : }
63 : :
64 [ # # ]: 0 : if (!ext4_dio_supported(inode)) {
65 : 0 : inode_unlock_shared(inode);
66 : : /*
67 : : * Fallback to buffered I/O if the operation being performed on
68 : : * the inode is not supported by direct I/O. The IOCB_DIRECT
69 : : * flag needs to be cleared here in order to ensure that the
70 : : * direct I/O path within generic_file_read_iter() is not
71 : : * taken.
72 : : */
73 : 0 : iocb->ki_flags &= ~IOCB_DIRECT;
74 : 0 : return generic_file_read_iter(iocb, to);
75 : : }
76 : :
77 : 0 : ret = iomap_dio_rw(iocb, to, &ext4_iomap_ops, NULL,
78 : 0 : is_sync_kiocb(iocb));
79 : 0 : inode_unlock_shared(inode);
80 : :
81 [ # # ]: 0 : file_accessed(iocb->ki_filp);
82 : : return ret;
83 : : }
84 : :
85 : : #ifdef CONFIG_FS_DAX
86 : : static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
87 : : {
88 : : struct inode *inode = file_inode(iocb->ki_filp);
89 : : ssize_t ret;
90 : :
91 : : if (iocb->ki_flags & IOCB_NOWAIT) {
92 : : if (!inode_trylock_shared(inode))
93 : : return -EAGAIN;
94 : : } else {
95 : : inode_lock_shared(inode);
96 : : }
97 : : /*
98 : : * Recheck under inode lock - at this point we are sure it cannot
99 : : * change anymore
100 : : */
101 : : if (!IS_DAX(inode)) {
102 : : inode_unlock_shared(inode);
103 : : /* Fallback to buffered IO in case we cannot support DAX */
104 : : return generic_file_read_iter(iocb, to);
105 : : }
106 : : ret = dax_iomap_rw(iocb, to, &ext4_iomap_ops);
107 : : inode_unlock_shared(inode);
108 : :
109 : : file_accessed(iocb->ki_filp);
110 : : return ret;
111 : : }
112 : : #endif
113 : :
114 : 293502 : static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
115 : : {
116 : 293502 : struct inode *inode = file_inode(iocb->ki_filp);
117 : :
118 [ + - ]: 293502 : if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
119 : : return -EIO;
120 : :
121 [ + - ]: 293502 : if (!iov_iter_count(to))
122 : : return 0; /* skip atime */
123 : :
124 : : #ifdef CONFIG_FS_DAX
125 : : if (IS_DAX(inode))
126 : : return ext4_dax_read_iter(iocb, to);
127 : : #endif
128 [ - + ]: 293502 : if (iocb->ki_flags & IOCB_DIRECT)
129 : 0 : return ext4_dio_read_iter(iocb, to);
130 : :
131 : 293502 : return generic_file_read_iter(iocb, to);
132 : : }
133 : :
134 : : /*
135 : : * Called when an inode is released. Note that this is different
136 : : * from ext4_file_open: open gets called at every open, but release
137 : : * gets called only when /all/ the files are closed.
138 : : */
139 : 484944 : static int ext4_release_file(struct inode *inode, struct file *filp)
140 : : {
141 [ - + ]: 484944 : if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
142 : 0 : ext4_alloc_da_blocks(inode);
143 : 0 : ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
144 : : }
145 : : /* if we are the last writer on the inode, drop the block reservation */
146 [ + + + - ]: 498030 : if ((filp->f_mode & FMODE_WRITE) &&
147 : 13086 : (atomic_read(&inode->i_writecount) == 1) &&
148 [ + + ]: 13086 : !EXT4_I(inode)->i_reserved_data_blocks)
149 : : {
150 : 570 : down_write(&EXT4_I(inode)->i_data_sem);
151 : 570 : ext4_discard_preallocations(inode);
152 : 570 : up_write(&EXT4_I(inode)->i_data_sem);
153 : : }
154 [ + - - + : 969888 : if (is_dx(inode) && filp->private_data)
- - ]
155 : 0 : ext4_htree_free_dir_info(filp->private_data);
156 : :
157 : 484944 : return 0;
158 : : }
159 : :
160 : : /*
161 : : * This tests whether the IO in question is block-aligned or not.
162 : : * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
163 : : * are converted to written only after the IO is complete. Until they are
164 : : * mapped, these blocks appear as holes, so dio_zero_block() will assume that
165 : : * it needs to zero out portions of the start and/or end block. If 2 AIO
166 : : * threads are at work on the same unwritten block, they must be synchronized
167 : : * or one thread will zero the other's data, causing corruption.
168 : : */
169 : : static bool
170 : 0 : ext4_unaligned_io(struct inode *inode, struct iov_iter *from, loff_t pos)
171 : : {
172 : 0 : struct super_block *sb = inode->i_sb;
173 : 0 : unsigned long blockmask = sb->s_blocksize - 1;
174 : :
175 [ # # ]: 0 : if ((pos | iov_iter_alignment(from)) & blockmask)
176 : 0 : return true;
177 : :
178 : : return false;
179 : : }
180 : :
181 : : static bool
182 : 0 : ext4_extending_io(struct inode *inode, loff_t offset, size_t len)
183 : : {
184 : 0 : if (offset + len > i_size_read(inode) ||
185 [ # # ]: 0 : offset + len > EXT4_I(inode)->i_disksize)
186 : 0 : return true;
187 : : return false;
188 : : }
189 : :
190 : : /* Is IO overwriting allocated and initialized blocks? */
191 : 0 : static bool ext4_overwrite_io(struct inode *inode, loff_t pos, loff_t len)
192 : : {
193 : 0 : struct ext4_map_blocks map;
194 : 0 : unsigned int blkbits = inode->i_blkbits;
195 : 0 : int err, blklen;
196 : :
197 [ # # ]: 0 : if (pos + len > i_size_read(inode))
198 : : return false;
199 : :
200 : 0 : map.m_lblk = pos >> blkbits;
201 : 0 : map.m_len = EXT4_MAX_BLOCKS(len, pos, blkbits);
202 : 0 : blklen = map.m_len;
203 : :
204 : 0 : err = ext4_map_blocks(NULL, inode, &map, 0);
205 : : /*
206 : : * 'err==len' means that all of the blocks have been preallocated,
207 : : * regardless of whether they have been initialized or not. To exclude
208 : : * unwritten extents, we need to check m_flags.
209 : : */
210 [ # # # # ]: 0 : return err == blklen && (map.m_flags & EXT4_MAP_MAPPED);
211 : : }
212 : :
213 : 20227 : static ssize_t ext4_generic_write_checks(struct kiocb *iocb,
214 : : struct iov_iter *from)
215 : : {
216 [ + - ]: 20227 : struct inode *inode = file_inode(iocb->ki_filp);
217 : 20227 : ssize_t ret;
218 : :
219 [ + - ]: 20227 : if (unlikely(IS_IMMUTABLE(inode)))
220 : : return -EPERM;
221 : :
222 : 20227 : ret = generic_write_checks(iocb, from);
223 [ + - ]: 20227 : if (ret <= 0)
224 : : return ret;
225 : :
226 : : /*
227 : : * If we have encountered a bitmap-format file, the size limit
228 : : * is smaller than s_maxbytes, which is for extent-mapped files.
229 : : */
230 [ - + ]: 20227 : if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
231 [ # # ]: 0 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
232 : :
233 [ # # ]: 0 : if (iocb->ki_pos >= sbi->s_bitmap_maxbytes)
234 : : return -EFBIG;
235 [ # # ]: 0 : iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
236 : : }
237 : :
238 : 20227 : return iov_iter_count(from);
239 : : }
240 : :
241 : 20227 : static ssize_t ext4_write_checks(struct kiocb *iocb, struct iov_iter *from)
242 : : {
243 : 20227 : ssize_t ret, count;
244 : :
245 : 20227 : count = ext4_generic_write_checks(iocb, from);
246 [ + - ]: 20227 : if (count <= 0)
247 : : return count;
248 : :
249 : 20227 : ret = file_modified(iocb->ki_filp);
250 [ - + ]: 20227 : if (ret)
251 : 0 : return ret;
252 : : return count;
253 : : }
254 : :
255 : 20227 : static ssize_t ext4_buffered_write_iter(struct kiocb *iocb,
256 : : struct iov_iter *from)
257 : : {
258 : 20227 : ssize_t ret;
259 [ + - ]: 20227 : struct inode *inode = file_inode(iocb->ki_filp);
260 : :
261 [ + - ]: 20227 : if (iocb->ki_flags & IOCB_NOWAIT)
262 : : return -EOPNOTSUPP;
263 : :
264 : 20227 : inode_lock(inode);
265 : 20227 : ret = ext4_write_checks(iocb, from);
266 [ - + ]: 20227 : if (ret <= 0)
267 : 0 : goto out;
268 : :
269 : 20227 : current->backing_dev_info = inode_to_bdi(inode);
270 : 20227 : ret = generic_perform_write(iocb->ki_filp, from, iocb->ki_pos);
271 : 20227 : current->backing_dev_info = NULL;
272 : :
273 : 20227 : out:
274 : 20227 : inode_unlock(inode);
275 [ + - ]: 20227 : if (likely(ret > 0)) {
276 : 20227 : iocb->ki_pos += ret;
277 : 20227 : ret = generic_write_sync(iocb, ret);
278 : : }
279 : :
280 : : return ret;
281 : : }
282 : :
283 : 0 : static ssize_t ext4_handle_inode_extension(struct inode *inode, loff_t offset,
284 : : ssize_t written, size_t count)
285 : : {
286 : 0 : handle_t *handle;
287 : 0 : bool truncate = false;
288 : 0 : u8 blkbits = inode->i_blkbits;
289 : 0 : ext4_lblk_t written_blk, end_blk;
290 : :
291 : : /*
292 : : * Note that EXT4_I(inode)->i_disksize can get extended up to
293 : : * inode->i_size while the I/O was running due to writeback of delalloc
294 : : * blocks. But, the code in ext4_iomap_alloc() is careful to use
295 : : * zeroed/unwritten extents if this is possible; thus we won't leave
296 : : * uninitialized blocks in a file even if we didn't succeed in writing
297 : : * as much as we intended.
298 : : */
299 [ # # ]: 0 : WARN_ON_ONCE(i_size_read(inode) < EXT4_I(inode)->i_disksize);
300 [ # # ]: 0 : if (offset + count <= EXT4_I(inode)->i_disksize) {
301 : : /*
302 : : * We need to ensure that the inode is removed from the orphan
303 : : * list if it has been added prematurely, due to writeback of
304 : : * delalloc blocks.
305 : : */
306 [ # # # # ]: 0 : if (!list_empty(&EXT4_I(inode)->i_orphan) && inode->i_nlink) {
307 : 0 : handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
308 : :
309 [ # # ]: 0 : if (IS_ERR(handle)) {
310 : 0 : ext4_orphan_del(NULL, inode);
311 : 0 : return PTR_ERR(handle);
312 : : }
313 : :
314 : 0 : ext4_orphan_del(handle, inode);
315 : 0 : ext4_journal_stop(handle);
316 : : }
317 : :
318 : 0 : return written;
319 : : }
320 : :
321 [ # # ]: 0 : if (written < 0)
322 : 0 : goto truncate;
323 : :
324 : 0 : handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
325 [ # # ]: 0 : if (IS_ERR(handle)) {
326 : 0 : written = PTR_ERR(handle);
327 : 0 : goto truncate;
328 : : }
329 : :
330 [ # # # # ]: 0 : if (ext4_update_inode_size(inode, offset + written))
331 : 0 : ext4_mark_inode_dirty(handle, inode);
332 : :
333 : : /*
334 : : * We may need to truncate allocated but not written blocks beyond EOF.
335 : : */
336 : 0 : written_blk = ALIGN(offset + written, 1 << blkbits);
337 : 0 : end_blk = ALIGN(offset + count, 1 << blkbits);
338 [ # # # # ]: 0 : if (written_blk < end_blk && ext4_can_truncate(inode))
339 : : truncate = true;
340 : :
341 : : /*
342 : : * Remove the inode from the orphan list if it has been extended and
343 : : * everything went OK.
344 : : */
345 [ # # ]: 0 : if (!truncate && inode->i_nlink)
346 : 0 : ext4_orphan_del(handle, inode);
347 : 0 : ext4_journal_stop(handle);
348 : :
349 [ # # ]: 0 : if (truncate) {
350 : 0 : truncate:
351 : 0 : ext4_truncate_failed_write(inode);
352 : : /*
353 : : * If the truncate operation failed early, then the inode may
354 : : * still be on the orphan list. In that case, we need to try
355 : : * remove the inode from the in-memory linked list.
356 : : */
357 [ # # ]: 0 : if (inode->i_nlink)
358 : 0 : ext4_orphan_del(NULL, inode);
359 : : }
360 : :
361 : : return written;
362 : : }
363 : :
364 : 0 : static int ext4_dio_write_end_io(struct kiocb *iocb, ssize_t size,
365 : : int error, unsigned int flags)
366 : : {
367 : 0 : loff_t offset = iocb->ki_pos;
368 [ # # ]: 0 : struct inode *inode = file_inode(iocb->ki_filp);
369 : :
370 [ # # ]: 0 : if (error)
371 : : return error;
372 : :
373 [ # # # # ]: 0 : if (size && flags & IOMAP_DIO_UNWRITTEN)
374 : 0 : return ext4_convert_unwritten_extents(NULL, inode,
375 : : offset, size);
376 : :
377 : : return 0;
378 : : }
379 : :
380 : : static const struct iomap_dio_ops ext4_dio_write_ops = {
381 : : .end_io = ext4_dio_write_end_io,
382 : : };
383 : :
384 : : /*
385 : : * The intention here is to start with shared lock acquired then see if any
386 : : * condition requires an exclusive inode lock. If yes, then we restart the
387 : : * whole operation by releasing the shared lock and acquiring exclusive lock.
388 : : *
389 : : * - For unaligned_io we never take shared lock as it may cause data corruption
390 : : * when two unaligned IO tries to modify the same block e.g. while zeroing.
391 : : *
392 : : * - For extending writes case we don't take the shared lock, since it requires
393 : : * updating inode i_disksize and/or orphan handling with exclusive lock.
394 : : *
395 : : * - shared locking will only be true mostly with overwrites. Otherwise we will
396 : : * switch to exclusive i_rwsem lock.
397 : : */
398 : 0 : static ssize_t ext4_dio_write_checks(struct kiocb *iocb, struct iov_iter *from,
399 : : bool *ilock_shared, bool *extend)
400 : : {
401 : 0 : struct file *file = iocb->ki_filp;
402 : 0 : struct inode *inode = file_inode(file);
403 : 0 : loff_t offset;
404 : 0 : size_t count;
405 : 0 : ssize_t ret;
406 : :
407 : 0 : restart:
408 : 0 : ret = ext4_generic_write_checks(iocb, from);
409 [ # # ]: 0 : if (ret <= 0)
410 : 0 : goto out;
411 : :
412 : 0 : offset = iocb->ki_pos;
413 : 0 : count = ret;
414 [ # # ]: 0 : if (ext4_extending_io(inode, offset, count))
415 : 0 : *extend = true;
416 : : /*
417 : : * Determine whether the IO operation will overwrite allocated
418 : : * and initialized blocks.
419 : : * We need exclusive i_rwsem for changing security info
420 : : * in file_modified().
421 : : */
422 [ # # # # : 0 : if (*ilock_shared && (!IS_NOSEC(inode) || *extend ||
# # # # ]
423 : 0 : !ext4_overwrite_io(inode, offset, count))) {
424 : 0 : inode_unlock_shared(inode);
425 : 0 : *ilock_shared = false;
426 : 0 : inode_lock(inode);
427 : 0 : goto restart;
428 : : }
429 : :
430 : 0 : ret = file_modified(file);
431 [ # # ]: 0 : if (ret < 0)
432 : 0 : goto out;
433 : :
434 : : return count;
435 : 0 : out:
436 [ # # ]: 0 : if (*ilock_shared)
437 : 0 : inode_unlock_shared(inode);
438 : : else
439 : 0 : inode_unlock(inode);
440 : : return ret;
441 : : }
442 : :
443 : 0 : static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
444 : : {
445 : 0 : ssize_t ret;
446 : 0 : handle_t *handle;
447 : 0 : struct inode *inode = file_inode(iocb->ki_filp);
448 : 0 : loff_t offset = iocb->ki_pos;
449 : 0 : size_t count = iov_iter_count(from);
450 : 0 : const struct iomap_ops *iomap_ops = &ext4_iomap_ops;
451 : 0 : bool extend = false, unaligned_io = false;
452 : 0 : bool ilock_shared = true;
453 : :
454 : : /*
455 : : * We initially start with shared inode lock unless it is
456 : : * unaligned IO which needs exclusive lock anyways.
457 : : */
458 : 0 : if (ext4_unaligned_io(inode, from, offset)) {
459 : 0 : unaligned_io = true;
460 : 0 : ilock_shared = false;
461 : : }
462 : : /*
463 : : * Quick check here without any i_rwsem lock to see if it is extending
464 : : * IO. A more reliable check is done in ext4_dio_write_checks() with
465 : : * proper locking in place.
466 : : */
467 [ # # ]: 0 : if (offset + count > i_size_read(inode))
468 : 0 : ilock_shared = false;
469 : :
470 [ # # ]: 0 : if (iocb->ki_flags & IOCB_NOWAIT) {
471 [ # # ]: 0 : if (ilock_shared) {
472 [ # # ]: 0 : if (!inode_trylock_shared(inode))
473 : : return -EAGAIN;
474 : : } else {
475 [ # # ]: 0 : if (!inode_trylock(inode))
476 : : return -EAGAIN;
477 : : }
478 : : } else {
479 [ # # ]: 0 : if (ilock_shared)
480 : 0 : inode_lock_shared(inode);
481 : : else
482 : 0 : inode_lock(inode);
483 : : }
484 : :
485 : : /* Fallback to buffered I/O if the inode does not support direct I/O. */
486 [ # # ]: 0 : if (!ext4_dio_supported(inode)) {
487 [ # # ]: 0 : if (ilock_shared)
488 : 0 : inode_unlock_shared(inode);
489 : : else
490 : 0 : inode_unlock(inode);
491 : 0 : return ext4_buffered_write_iter(iocb, from);
492 : : }
493 : :
494 : 0 : ret = ext4_dio_write_checks(iocb, from, &ilock_shared, &extend);
495 [ # # ]: 0 : if (ret <= 0)
496 : : return ret;
497 : :
498 : 0 : offset = iocb->ki_pos;
499 : 0 : count = ret;
500 : :
501 : : /*
502 : : * Unaligned direct IO must be serialized among each other as zeroing
503 : : * of partial blocks of two competing unaligned IOs can result in data
504 : : * corruption.
505 : : *
506 : : * So we make sure we don't allow any unaligned IO in flight.
507 : : * For IOs where we need not wait (like unaligned non-AIO DIO),
508 : : * below inode_dio_wait() may anyway become a no-op, since we start
509 : : * with exclusive lock.
510 : : */
511 [ # # ]: 0 : if (unaligned_io)
512 : 0 : inode_dio_wait(inode);
513 : :
514 [ # # ]: 0 : if (extend) {
515 : 0 : handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
516 [ # # ]: 0 : if (IS_ERR(handle)) {
517 : 0 : ret = PTR_ERR(handle);
518 : 0 : goto out;
519 : : }
520 : :
521 : 0 : ret = ext4_orphan_add(handle, inode);
522 [ # # ]: 0 : if (ret) {
523 : 0 : ext4_journal_stop(handle);
524 : 0 : goto out;
525 : : }
526 : :
527 : 0 : ext4_journal_stop(handle);
528 : : }
529 : :
530 [ # # ]: 0 : if (ilock_shared)
531 : 0 : iomap_ops = &ext4_iomap_overwrite_ops;
532 : 0 : ret = iomap_dio_rw(iocb, from, iomap_ops, &ext4_dio_write_ops,
533 [ # # # # : 0 : is_sync_kiocb(iocb) || unaligned_io || extend);
# # ]
534 : :
535 [ # # ]: 0 : if (extend)
536 : 0 : ret = ext4_handle_inode_extension(inode, offset, ret, count);
537 : :
538 : 0 : out:
539 [ # # ]: 0 : if (ilock_shared)
540 : 0 : inode_unlock_shared(inode);
541 : : else
542 : 0 : inode_unlock(inode);
543 : :
544 [ # # # # ]: 0 : if (ret >= 0 && iov_iter_count(from)) {
545 : 0 : ssize_t err;
546 : 0 : loff_t endbyte;
547 : :
548 : 0 : offset = iocb->ki_pos;
549 : 0 : err = ext4_buffered_write_iter(iocb, from);
550 [ # # ]: 0 : if (err < 0)
551 : : return err;
552 : :
553 : : /*
554 : : * We need to ensure that the pages within the page cache for
555 : : * the range covered by this I/O are written to disk and
556 : : * invalidated. This is in attempt to preserve the expected
557 : : * direct I/O semantics in the case we fallback to buffered I/O
558 : : * to complete off the I/O request.
559 : : */
560 : 0 : ret += err;
561 : 0 : endbyte = offset + err - 1;
562 : 0 : err = filemap_write_and_wait_range(iocb->ki_filp->f_mapping,
563 : : offset, endbyte);
564 [ # # ]: 0 : if (!err)
565 : 0 : invalidate_mapping_pages(iocb->ki_filp->f_mapping,
566 : 0 : offset >> PAGE_SHIFT,
567 : 0 : endbyte >> PAGE_SHIFT);
568 : : }
569 : :
570 : : return ret;
571 : : }
572 : :
573 : : #ifdef CONFIG_FS_DAX
574 : : static ssize_t
575 : : ext4_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
576 : : {
577 : : ssize_t ret;
578 : : size_t count;
579 : : loff_t offset;
580 : : handle_t *handle;
581 : : bool extend = false;
582 : : struct inode *inode = file_inode(iocb->ki_filp);
583 : :
584 : : if (iocb->ki_flags & IOCB_NOWAIT) {
585 : : if (!inode_trylock(inode))
586 : : return -EAGAIN;
587 : : } else {
588 : : inode_lock(inode);
589 : : }
590 : :
591 : : ret = ext4_write_checks(iocb, from);
592 : : if (ret <= 0)
593 : : goto out;
594 : :
595 : : offset = iocb->ki_pos;
596 : : count = iov_iter_count(from);
597 : :
598 : : if (offset + count > EXT4_I(inode)->i_disksize) {
599 : : handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
600 : : if (IS_ERR(handle)) {
601 : : ret = PTR_ERR(handle);
602 : : goto out;
603 : : }
604 : :
605 : : ret = ext4_orphan_add(handle, inode);
606 : : if (ret) {
607 : : ext4_journal_stop(handle);
608 : : goto out;
609 : : }
610 : :
611 : : extend = true;
612 : : ext4_journal_stop(handle);
613 : : }
614 : :
615 : : ret = dax_iomap_rw(iocb, from, &ext4_iomap_ops);
616 : :
617 : : if (extend)
618 : : ret = ext4_handle_inode_extension(inode, offset, ret, count);
619 : : out:
620 : : inode_unlock(inode);
621 : : if (ret > 0)
622 : : ret = generic_write_sync(iocb, ret);
623 : : return ret;
624 : : }
625 : : #endif
626 : :
627 : : static ssize_t
628 : 20227 : ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
629 : : {
630 : 20227 : struct inode *inode = file_inode(iocb->ki_filp);
631 : :
632 [ + - ]: 20227 : if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
633 : : return -EIO;
634 : :
635 : : #ifdef CONFIG_FS_DAX
636 : : if (IS_DAX(inode))
637 : : return ext4_dax_write_iter(iocb, from);
638 : : #endif
639 [ - + ]: 20227 : if (iocb->ki_flags & IOCB_DIRECT)
640 : 0 : return ext4_dio_write_iter(iocb, from);
641 : :
642 : 20227 : return ext4_buffered_write_iter(iocb, from);
643 : : }
644 : :
645 : : #ifdef CONFIG_FS_DAX
646 : : static vm_fault_t ext4_dax_huge_fault(struct vm_fault *vmf,
647 : : enum page_entry_size pe_size)
648 : : {
649 : : int error = 0;
650 : : vm_fault_t result;
651 : : int retries = 0;
652 : : handle_t *handle = NULL;
653 : : struct inode *inode = file_inode(vmf->vma->vm_file);
654 : : struct super_block *sb = inode->i_sb;
655 : :
656 : : /*
657 : : * We have to distinguish real writes from writes which will result in a
658 : : * COW page; COW writes should *not* poke the journal (the file will not
659 : : * be changed). Doing so would cause unintended failures when mounted
660 : : * read-only.
661 : : *
662 : : * We check for VM_SHARED rather than vmf->cow_page since the latter is
663 : : * unset for pe_size != PE_SIZE_PTE (i.e. only in do_cow_fault); for
664 : : * other sizes, dax_iomap_fault will handle splitting / fallback so that
665 : : * we eventually come back with a COW page.
666 : : */
667 : : bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
668 : : (vmf->vma->vm_flags & VM_SHARED);
669 : : pfn_t pfn;
670 : :
671 : : if (write) {
672 : : sb_start_pagefault(sb);
673 : : file_update_time(vmf->vma->vm_file);
674 : : down_read(&EXT4_I(inode)->i_mmap_sem);
675 : : retry:
676 : : handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
677 : : EXT4_DATA_TRANS_BLOCKS(sb));
678 : : if (IS_ERR(handle)) {
679 : : up_read(&EXT4_I(inode)->i_mmap_sem);
680 : : sb_end_pagefault(sb);
681 : : return VM_FAULT_SIGBUS;
682 : : }
683 : : } else {
684 : : down_read(&EXT4_I(inode)->i_mmap_sem);
685 : : }
686 : : result = dax_iomap_fault(vmf, pe_size, &pfn, &error, &ext4_iomap_ops);
687 : : if (write) {
688 : : ext4_journal_stop(handle);
689 : :
690 : : if ((result & VM_FAULT_ERROR) && error == -ENOSPC &&
691 : : ext4_should_retry_alloc(sb, &retries))
692 : : goto retry;
693 : : /* Handling synchronous page fault? */
694 : : if (result & VM_FAULT_NEEDDSYNC)
695 : : result = dax_finish_sync_fault(vmf, pe_size, pfn);
696 : : up_read(&EXT4_I(inode)->i_mmap_sem);
697 : : sb_end_pagefault(sb);
698 : : } else {
699 : : up_read(&EXT4_I(inode)->i_mmap_sem);
700 : : }
701 : :
702 : : return result;
703 : : }
704 : :
705 : : static vm_fault_t ext4_dax_fault(struct vm_fault *vmf)
706 : : {
707 : : return ext4_dax_huge_fault(vmf, PE_SIZE_PTE);
708 : : }
709 : :
710 : : static const struct vm_operations_struct ext4_dax_vm_ops = {
711 : : .fault = ext4_dax_fault,
712 : : .huge_fault = ext4_dax_huge_fault,
713 : : .page_mkwrite = ext4_dax_fault,
714 : : .pfn_mkwrite = ext4_dax_fault,
715 : : };
716 : : #else
717 : : #define ext4_dax_vm_ops ext4_file_vm_ops
718 : : #endif
719 : :
720 : : static const struct vm_operations_struct ext4_file_vm_ops = {
721 : : .fault = ext4_filemap_fault,
722 : : .map_pages = filemap_map_pages,
723 : : .page_mkwrite = ext4_page_mkwrite,
724 : : };
725 : :
726 : 905148 : static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
727 : : {
728 : 905148 : struct inode *inode = file->f_mapping->host;
729 : 905148 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
730 : 905148 : struct dax_device *dax_dev = sbi->s_daxdev;
731 : :
732 [ + - ]: 905148 : if (unlikely(ext4_forced_shutdown(sbi)))
733 : : return -EIO;
734 : :
735 : : /*
736 : : * We don't support synchronous mappings for non-DAX files and
737 : : * for DAX files if underneath dax_device is not synchronous.
738 : : */
739 [ + - ]: 905148 : if (!daxdev_mapping_supported(vma, dax_dev))
740 : : return -EOPNOTSUPP;
741 : :
742 [ + - ]: 905148 : file_accessed(file);
743 : 905148 : if (IS_DAX(file_inode(file))) {
744 : : vma->vm_ops = &ext4_dax_vm_ops;
745 : : vma->vm_flags |= VM_HUGEPAGE;
746 : : } else {
747 : 905148 : vma->vm_ops = &ext4_file_vm_ops;
748 : : }
749 : 905148 : return 0;
750 : : }
751 : :
752 : 493290 : static int ext4_sample_last_mounted(struct super_block *sb,
753 : : struct vfsmount *mnt)
754 : : {
755 [ + + ]: 493290 : struct ext4_sb_info *sbi = EXT4_SB(sb);
756 : 493290 : struct path path;
757 : 493290 : char buf[64], *cp;
758 : 493290 : handle_t *handle;
759 : 493290 : int err;
760 : :
761 [ + + ]: 493290 : if (likely(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED))
762 : : return 0;
763 : :
764 [ + + - + ]: 22893 : if (sb_rdonly(sb) || !sb_start_intwrite_trylock(sb))
765 : 22833 : return 0;
766 : :
767 : 30 : sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
768 : : /*
769 : : * Sample where the filesystem has been mounted and
770 : : * store it in the superblock for sysadmin convenience
771 : : * when trying to sort through large numbers of block
772 : : * devices or filesystem images.
773 : : */
774 : 30 : memset(buf, 0, sizeof(buf));
775 : 30 : path.mnt = mnt;
776 : 30 : path.dentry = mnt->mnt_root;
777 : 30 : cp = d_path(&path, buf, sizeof(buf));
778 : 30 : err = 0;
779 [ - + ]: 30 : if (IS_ERR(cp))
780 : 0 : goto out;
781 : :
782 : 30 : handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
783 [ - + ]: 30 : err = PTR_ERR(handle);
784 [ - + ]: 30 : if (IS_ERR(handle))
785 : 0 : goto out;
786 : 30 : BUFFER_TRACE(sbi->s_sbh, "get_write_access");
787 : 30 : err = ext4_journal_get_write_access(handle, sbi->s_sbh);
788 [ - + ]: 30 : if (err)
789 : 0 : goto out_journal;
790 : 30 : strlcpy(sbi->s_es->s_last_mounted, cp,
791 : : sizeof(sbi->s_es->s_last_mounted));
792 : 30 : ext4_handle_dirty_super(handle, sb);
793 : 30 : out_journal:
794 : 30 : ext4_journal_stop(handle);
795 : 30 : out:
796 : 30 : sb_end_intwrite(sb);
797 : 30 : return err;
798 : : }
799 : :
800 : 493290 : static int ext4_file_open(struct inode * inode, struct file * filp)
801 : : {
802 : 493290 : int ret;
803 : :
804 [ + - ]: 493290 : if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
805 : : return -EIO;
806 : :
807 : 493290 : ret = ext4_sample_last_mounted(inode->i_sb, filp->f_path.mnt);
808 [ + - ]: 493290 : if (ret)
809 : : return ret;
810 : :
811 [ + - ]: 493290 : ret = fscrypt_file_open(inode, filp);
812 : 493290 : if (ret)
813 : : return ret;
814 : :
815 [ + - ]: 493290 : ret = fsverity_file_open(inode, filp);
816 : 493290 : if (ret)
817 : : return ret;
818 : :
819 : : /*
820 : : * Set up the jbd2_inode if we are opening the inode for
821 : : * writing and the journal is present
822 : : */
823 [ + + ]: 493290 : if (filp->f_mode & FMODE_WRITE) {
824 : 13266 : ret = ext4_inode_attach_jinode(inode);
825 [ + - ]: 13266 : if (ret < 0)
826 : : return ret;
827 : : }
828 : :
829 : 493290 : filp->f_mode |= FMODE_NOWAIT;
830 : 493290 : return dquot_file_open(inode, filp);
831 : : }
832 : :
833 : : /*
834 : : * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
835 : : * by calling generic_file_llseek_size() with the appropriate maxbytes
836 : : * value for each.
837 : : */
838 : 12600 : loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
839 : : {
840 : 12600 : struct inode *inode = file->f_mapping->host;
841 : 12600 : loff_t maxbytes;
842 : :
843 [ - + ]: 12600 : if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
844 : 0 : maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
845 : : else
846 : 12600 : maxbytes = inode->i_sb->s_maxbytes;
847 : :
848 [ + - - ]: 12600 : switch (whence) {
849 : 12600 : default:
850 : 12600 : return generic_file_llseek_size(file, offset, whence,
851 : : maxbytes, i_size_read(inode));
852 : : case SEEK_HOLE:
853 : 0 : inode_lock_shared(inode);
854 : 0 : offset = iomap_seek_hole(inode, offset,
855 : : &ext4_iomap_report_ops);
856 : 0 : inode_unlock_shared(inode);
857 : : break;
858 : : case SEEK_DATA:
859 : 0 : inode_lock_shared(inode);
860 : 0 : offset = iomap_seek_data(inode, offset,
861 : : &ext4_iomap_report_ops);
862 : 0 : inode_unlock_shared(inode);
863 : : break;
864 : : }
865 : :
866 [ # # ]: 0 : if (offset < 0)
867 : : return offset;
868 : 0 : return vfs_setpos(file, offset, maxbytes);
869 : : }
870 : :
871 : : const struct file_operations ext4_file_operations = {
872 : : .llseek = ext4_llseek,
873 : : .read_iter = ext4_file_read_iter,
874 : : .write_iter = ext4_file_write_iter,
875 : : .unlocked_ioctl = ext4_ioctl,
876 : : #ifdef CONFIG_COMPAT
877 : : .compat_ioctl = ext4_compat_ioctl,
878 : : #endif
879 : : .mmap = ext4_file_mmap,
880 : : .mmap_supported_flags = MAP_SYNC,
881 : : .open = ext4_file_open,
882 : : .release = ext4_release_file,
883 : : .fsync = ext4_sync_file,
884 : : .get_unmapped_area = thp_get_unmapped_area,
885 : : .splice_read = generic_file_splice_read,
886 : : .splice_write = iter_file_splice_write,
887 : : .fallocate = ext4_fallocate,
888 : : };
889 : :
890 : : const struct inode_operations ext4_file_inode_operations = {
891 : : .setattr = ext4_setattr,
892 : : .getattr = ext4_file_getattr,
893 : : .listxattr = ext4_listxattr,
894 : : .get_acl = ext4_get_acl,
895 : : .set_acl = ext4_set_acl,
896 : : .fiemap = ext4_fiemap,
897 : : };
898 : :
|
