1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * fs/f2fs/file.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8 #include <linux/fs.h>
9 #include <linux/f2fs_fs.h>
10 #include <linux/stat.h>
11 #include <linux/buffer_head.h>
12 #include <linux/writeback.h>
13 #include <linux/blkdev.h>
14 #include <linux/falloc.h>
15 #include <linux/types.h>
16 #include <linux/compat.h>
17 #include <linux/uaccess.h>
18 #include <linux/mount.h>
19 #include <linux/pagevec.h>
20 #include <linux/uio.h>
21 #include <linux/uuid.h>
22 #include <linux/file.h>
23 #include <linux/nls.h>
24 #include <linux/sched/signal.h>
25 #include <linux/fileattr.h>
26 #include <linux/fadvise.h>
27 #include <linux/iomap.h>
28
29 #include "f2fs.h"
30 #include "node.h"
31 #include "segment.h"
32 #include "xattr.h"
33 #include "acl.h"
34 #include "gc.h"
35 #include "iostat.h"
36 #include <trace/events/f2fs.h>
37 #include <uapi/linux/f2fs.h>
38
f2fs_filemap_fault(struct vm_fault * vmf)39 static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
40 {
41 struct inode *inode = file_inode(vmf->vma->vm_file);
42 vm_flags_t flags = vmf->vma->vm_flags;
43 vm_fault_t ret;
44
45 ret = filemap_fault(vmf);
46 if (ret & VM_FAULT_LOCKED)
47 f2fs_update_iostat(F2FS_I_SB(inode), inode,
48 APP_MAPPED_READ_IO, F2FS_BLKSIZE);
49
50 trace_f2fs_filemap_fault(inode, vmf->pgoff, flags, ret);
51
52 return ret;
53 }
54
f2fs_vm_page_mkwrite(struct vm_fault * vmf)55 static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
56 {
57 struct page *page = vmf->page;
58 struct inode *inode = file_inode(vmf->vma->vm_file);
59 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
60 struct dnode_of_data dn;
61 bool need_alloc = !f2fs_is_pinned_file(inode);
62 int err = 0;
63 vm_fault_t ret;
64
65 if (unlikely(IS_IMMUTABLE(inode)))
66 return VM_FAULT_SIGBUS;
67
68 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
69 err = -EIO;
70 goto out;
71 }
72
73 if (unlikely(f2fs_cp_error(sbi))) {
74 err = -EIO;
75 goto out;
76 }
77
78 if (!f2fs_is_checkpoint_ready(sbi)) {
79 err = -ENOSPC;
80 goto out;
81 }
82
83 err = f2fs_convert_inline_inode(inode);
84 if (err)
85 goto out;
86
87 #ifdef CONFIG_F2FS_FS_COMPRESSION
88 if (f2fs_compressed_file(inode)) {
89 int ret = f2fs_is_compressed_cluster(inode, page->index);
90
91 if (ret < 0) {
92 err = ret;
93 goto out;
94 } else if (ret) {
95 need_alloc = false;
96 }
97 }
98 #endif
99 /* should do out of any locked page */
100 if (need_alloc)
101 f2fs_balance_fs(sbi, true);
102
103 sb_start_pagefault(inode->i_sb);
104
105 f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
106
107 file_update_time(vmf->vma->vm_file);
108 filemap_invalidate_lock_shared(inode->i_mapping);
109 lock_page(page);
110 if (unlikely(page->mapping != inode->i_mapping ||
111 page_offset(page) > i_size_read(inode) ||
112 !PageUptodate(page))) {
113 unlock_page(page);
114 err = -EFAULT;
115 goto out_sem;
116 }
117
118 set_new_dnode(&dn, inode, NULL, NULL, 0);
119 if (need_alloc) {
120 /* block allocation */
121 err = f2fs_get_block_locked(&dn, page->index);
122 } else {
123 err = f2fs_get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
124 f2fs_put_dnode(&dn);
125 if (f2fs_is_pinned_file(inode) &&
126 !__is_valid_data_blkaddr(dn.data_blkaddr))
127 err = -EIO;
128 }
129
130 if (err) {
131 unlock_page(page);
132 goto out_sem;
133 }
134
135 f2fs_wait_on_page_writeback(page, DATA, false, true);
136
137 /* wait for GCed page writeback via META_MAPPING */
138 f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
139
140 /*
141 * check to see if the page is mapped already (no holes)
142 */
143 if (PageMappedToDisk(page))
144 goto out_sem;
145
146 /* page is wholly or partially inside EOF */
147 if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
148 i_size_read(inode)) {
149 loff_t offset;
150
151 offset = i_size_read(inode) & ~PAGE_MASK;
152 zero_user_segment(page, offset, PAGE_SIZE);
153 }
154 set_page_dirty(page);
155
156 f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE);
157 f2fs_update_time(sbi, REQ_TIME);
158
159 out_sem:
160 filemap_invalidate_unlock_shared(inode->i_mapping);
161
162 sb_end_pagefault(inode->i_sb);
163 out:
164 ret = vmf_fs_error(err);
165
166 trace_f2fs_vm_page_mkwrite(inode, page->index, vmf->vma->vm_flags, ret);
167 return ret;
168 }
169
170 static const struct vm_operations_struct f2fs_file_vm_ops = {
171 .fault = f2fs_filemap_fault,
172 .map_pages = filemap_map_pages,
173 .page_mkwrite = f2fs_vm_page_mkwrite,
174 };
175
get_parent_ino(struct inode * inode,nid_t * pino)176 static int get_parent_ino(struct inode *inode, nid_t *pino)
177 {
178 struct dentry *dentry;
179
180 /*
181 * Make sure to get the non-deleted alias. The alias associated with
182 * the open file descriptor being fsync()'ed may be deleted already.
183 */
184 dentry = d_find_alias(inode);
185 if (!dentry)
186 return 0;
187
188 *pino = d_parent_ino(dentry);
189 dput(dentry);
190 return 1;
191 }
192
need_do_checkpoint(struct inode * inode)193 static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
194 {
195 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
196 enum cp_reason_type cp_reason = CP_NO_NEEDED;
197
198 if (!S_ISREG(inode->i_mode))
199 cp_reason = CP_NON_REGULAR;
200 else if (f2fs_compressed_file(inode))
201 cp_reason = CP_COMPRESSED;
202 else if (inode->i_nlink != 1)
203 cp_reason = CP_HARDLINK;
204 else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
205 cp_reason = CP_SB_NEED_CP;
206 else if (file_wrong_pino(inode))
207 cp_reason = CP_WRONG_PINO;
208 else if (!f2fs_space_for_roll_forward(sbi))
209 cp_reason = CP_NO_SPC_ROLL;
210 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
211 cp_reason = CP_NODE_NEED_CP;
212 else if (test_opt(sbi, FASTBOOT))
213 cp_reason = CP_FASTBOOT_MODE;
214 else if (F2FS_OPTION(sbi).active_logs == 2)
215 cp_reason = CP_SPEC_LOG_NUM;
216 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT &&
217 f2fs_need_dentry_mark(sbi, inode->i_ino) &&
218 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
219 TRANS_DIR_INO))
220 cp_reason = CP_RECOVER_DIR;
221
222 return cp_reason;
223 }
224
need_inode_page_update(struct f2fs_sb_info * sbi,nid_t ino)225 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
226 {
227 struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
228 bool ret = false;
229 /* But we need to avoid that there are some inode updates */
230 if ((i && PageDirty(i)) || f2fs_need_inode_block_update(sbi, ino))
231 ret = true;
232 f2fs_put_page(i, 0);
233 return ret;
234 }
235
try_to_fix_pino(struct inode * inode)236 static void try_to_fix_pino(struct inode *inode)
237 {
238 struct f2fs_inode_info *fi = F2FS_I(inode);
239 nid_t pino;
240
241 f2fs_down_write(&fi->i_sem);
242 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
243 get_parent_ino(inode, &pino)) {
244 f2fs_i_pino_write(inode, pino);
245 file_got_pino(inode);
246 }
247 f2fs_up_write(&fi->i_sem);
248 }
249
f2fs_do_sync_file(struct file * file,loff_t start,loff_t end,int datasync,bool atomic)250 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
251 int datasync, bool atomic)
252 {
253 struct inode *inode = file->f_mapping->host;
254 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
255 nid_t ino = inode->i_ino;
256 int ret = 0;
257 enum cp_reason_type cp_reason = 0;
258 struct writeback_control wbc = {
259 .sync_mode = WB_SYNC_ALL,
260 .nr_to_write = LONG_MAX,
261 .for_reclaim = 0,
262 };
263 unsigned int seq_id = 0;
264
265 if (unlikely(f2fs_readonly(inode->i_sb)))
266 return 0;
267
268 trace_f2fs_sync_file_enter(inode);
269
270 if (S_ISDIR(inode->i_mode))
271 goto go_write;
272
273 /* if fdatasync is triggered, let's do in-place-update */
274 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
275 set_inode_flag(inode, FI_NEED_IPU);
276 ret = file_write_and_wait_range(file, start, end);
277 clear_inode_flag(inode, FI_NEED_IPU);
278
279 if (ret || is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
280 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
281 return ret;
282 }
283
284 /* if the inode is dirty, let's recover all the time */
285 if (!f2fs_skip_inode_update(inode, datasync)) {
286 f2fs_write_inode(inode, NULL);
287 goto go_write;
288 }
289
290 /*
291 * if there is no written data, don't waste time to write recovery info.
292 */
293 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
294 !f2fs_exist_written_data(sbi, ino, APPEND_INO)) {
295
296 /* it may call write_inode just prior to fsync */
297 if (need_inode_page_update(sbi, ino))
298 goto go_write;
299
300 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
301 f2fs_exist_written_data(sbi, ino, UPDATE_INO))
302 goto flush_out;
303 goto out;
304 } else {
305 /*
306 * for OPU case, during fsync(), node can be persisted before
307 * data when lower device doesn't support write barrier, result
308 * in data corruption after SPO.
309 * So for strict fsync mode, force to use atomic write semantics
310 * to keep write order in between data/node and last node to
311 * avoid potential data corruption.
312 */
313 if (F2FS_OPTION(sbi).fsync_mode ==
314 FSYNC_MODE_STRICT && !atomic)
315 atomic = true;
316 }
317 go_write:
318 /*
319 * Both of fdatasync() and fsync() are able to be recovered from
320 * sudden-power-off.
321 */
322 f2fs_down_read(&F2FS_I(inode)->i_sem);
323 cp_reason = need_do_checkpoint(inode);
324 f2fs_up_read(&F2FS_I(inode)->i_sem);
325
326 if (cp_reason) {
327 /* all the dirty node pages should be flushed for POR */
328 ret = f2fs_sync_fs(inode->i_sb, 1);
329
330 /*
331 * We've secured consistency through sync_fs. Following pino
332 * will be used only for fsynced inodes after checkpoint.
333 */
334 try_to_fix_pino(inode);
335 clear_inode_flag(inode, FI_APPEND_WRITE);
336 clear_inode_flag(inode, FI_UPDATE_WRITE);
337 goto out;
338 }
339 sync_nodes:
340 atomic_inc(&sbi->wb_sync_req[NODE]);
341 ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id);
342 atomic_dec(&sbi->wb_sync_req[NODE]);
343 if (ret)
344 goto out;
345
346 /* if cp_error was enabled, we should avoid infinite loop */
347 if (unlikely(f2fs_cp_error(sbi))) {
348 ret = -EIO;
349 goto out;
350 }
351
352 if (f2fs_need_inode_block_update(sbi, ino)) {
353 f2fs_mark_inode_dirty_sync(inode, true);
354 f2fs_write_inode(inode, NULL);
355 goto sync_nodes;
356 }
357
358 /*
359 * If it's atomic_write, it's just fine to keep write ordering. So
360 * here we don't need to wait for node write completion, since we use
361 * node chain which serializes node blocks. If one of node writes are
362 * reordered, we can see simply broken chain, resulting in stopping
363 * roll-forward recovery. It means we'll recover all or none node blocks
364 * given fsync mark.
365 */
366 if (!atomic) {
367 ret = f2fs_wait_on_node_pages_writeback(sbi, seq_id);
368 if (ret)
369 goto out;
370 }
371
372 /* once recovery info is written, don't need to tack this */
373 f2fs_remove_ino_entry(sbi, ino, APPEND_INO);
374 clear_inode_flag(inode, FI_APPEND_WRITE);
375 flush_out:
376 if ((!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER) ||
377 (atomic && !test_opt(sbi, NOBARRIER) && f2fs_sb_has_blkzoned(sbi)))
378 ret = f2fs_issue_flush(sbi, inode->i_ino);
379 if (!ret) {
380 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
381 clear_inode_flag(inode, FI_UPDATE_WRITE);
382 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
383 }
384 f2fs_update_time(sbi, REQ_TIME);
385 out:
386 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
387 return ret;
388 }
389
f2fs_sync_file(struct file * file,loff_t start,loff_t end,int datasync)390 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
391 {
392 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
393 return -EIO;
394 return f2fs_do_sync_file(file, start, end, datasync, false);
395 }
396
__found_offset(struct address_space * mapping,struct dnode_of_data * dn,pgoff_t index,int whence)397 static bool __found_offset(struct address_space *mapping,
398 struct dnode_of_data *dn, pgoff_t index, int whence)
399 {
400 block_t blkaddr = f2fs_data_blkaddr(dn);
401 struct inode *inode = mapping->host;
402 bool compressed_cluster = false;
403
404 if (f2fs_compressed_file(inode)) {
405 block_t first_blkaddr = data_blkaddr(dn->inode, dn->node_page,
406 ALIGN_DOWN(dn->ofs_in_node, F2FS_I(inode)->i_cluster_size));
407
408 compressed_cluster = first_blkaddr == COMPRESS_ADDR;
409 }
410
411 switch (whence) {
412 case SEEK_DATA:
413 if (__is_valid_data_blkaddr(blkaddr))
414 return true;
415 if (blkaddr == NEW_ADDR &&
416 xa_get_mark(&mapping->i_pages, index, PAGECACHE_TAG_DIRTY))
417 return true;
418 if (compressed_cluster)
419 return true;
420 break;
421 case SEEK_HOLE:
422 if (compressed_cluster)
423 return false;
424 if (blkaddr == NULL_ADDR)
425 return true;
426 break;
427 }
428 return false;
429 }
430
f2fs_seek_block(struct file * file,loff_t offset,int whence)431 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
432 {
433 struct inode *inode = file->f_mapping->host;
434 loff_t maxbytes = inode->i_sb->s_maxbytes;
435 struct dnode_of_data dn;
436 pgoff_t pgofs, end_offset;
437 loff_t data_ofs = offset;
438 loff_t isize;
439 int err = 0;
440
441 inode_lock_shared(inode);
442
443 isize = i_size_read(inode);
444 if (offset >= isize)
445 goto fail;
446
447 /* handle inline data case */
448 if (f2fs_has_inline_data(inode)) {
449 if (whence == SEEK_HOLE) {
450 data_ofs = isize;
451 goto found;
452 } else if (whence == SEEK_DATA) {
453 data_ofs = offset;
454 goto found;
455 }
456 }
457
458 pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
459
460 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
461 set_new_dnode(&dn, inode, NULL, NULL, 0);
462 err = f2fs_get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
463 if (err && err != -ENOENT) {
464 goto fail;
465 } else if (err == -ENOENT) {
466 /* direct node does not exists */
467 if (whence == SEEK_DATA) {
468 pgofs = f2fs_get_next_page_offset(&dn, pgofs);
469 continue;
470 } else {
471 goto found;
472 }
473 }
474
475 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
476
477 /* find data/hole in dnode block */
478 for (; dn.ofs_in_node < end_offset;
479 dn.ofs_in_node++, pgofs++,
480 data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
481 block_t blkaddr;
482
483 blkaddr = f2fs_data_blkaddr(&dn);
484
485 if (__is_valid_data_blkaddr(blkaddr) &&
486 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
487 blkaddr, DATA_GENERIC_ENHANCE)) {
488 f2fs_put_dnode(&dn);
489 goto fail;
490 }
491
492 if (__found_offset(file->f_mapping, &dn,
493 pgofs, whence)) {
494 f2fs_put_dnode(&dn);
495 goto found;
496 }
497 }
498 f2fs_put_dnode(&dn);
499 }
500
501 if (whence == SEEK_DATA)
502 goto fail;
503 found:
504 if (whence == SEEK_HOLE && data_ofs > isize)
505 data_ofs = isize;
506 inode_unlock_shared(inode);
507 return vfs_setpos(file, data_ofs, maxbytes);
508 fail:
509 inode_unlock_shared(inode);
510 return -ENXIO;
511 }
512
f2fs_llseek(struct file * file,loff_t offset,int whence)513 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
514 {
515 struct inode *inode = file->f_mapping->host;
516 loff_t maxbytes = inode->i_sb->s_maxbytes;
517
518 if (f2fs_compressed_file(inode))
519 maxbytes = max_file_blocks(inode) << F2FS_BLKSIZE_BITS;
520
521 switch (whence) {
522 case SEEK_SET:
523 case SEEK_CUR:
524 case SEEK_END:
525 return generic_file_llseek_size(file, offset, whence,
526 maxbytes, i_size_read(inode));
527 case SEEK_DATA:
528 case SEEK_HOLE:
529 if (offset < 0)
530 return -ENXIO;
531 return f2fs_seek_block(file, offset, whence);
532 }
533
534 return -EINVAL;
535 }
536
f2fs_file_mmap(struct file * file,struct vm_area_struct * vma)537 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
538 {
539 struct inode *inode = file_inode(file);
540
541 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
542 return -EIO;
543
544 if (!f2fs_is_compress_backend_ready(inode))
545 return -EOPNOTSUPP;
546
547 file_accessed(file);
548 vma->vm_ops = &f2fs_file_vm_ops;
549
550 f2fs_down_read(&F2FS_I(inode)->i_sem);
551 set_inode_flag(inode, FI_MMAP_FILE);
552 f2fs_up_read(&F2FS_I(inode)->i_sem);
553
554 return 0;
555 }
556
finish_preallocate_blocks(struct inode * inode)557 static int finish_preallocate_blocks(struct inode *inode)
558 {
559 int ret;
560
561 inode_lock(inode);
562 if (is_inode_flag_set(inode, FI_OPENED_FILE)) {
563 inode_unlock(inode);
564 return 0;
565 }
566
567 if (!file_should_truncate(inode)) {
568 set_inode_flag(inode, FI_OPENED_FILE);
569 inode_unlock(inode);
570 return 0;
571 }
572
573 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
574 filemap_invalidate_lock(inode->i_mapping);
575
576 truncate_setsize(inode, i_size_read(inode));
577 ret = f2fs_truncate(inode);
578
579 filemap_invalidate_unlock(inode->i_mapping);
580 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
581
582 if (!ret)
583 set_inode_flag(inode, FI_OPENED_FILE);
584
585 inode_unlock(inode);
586 if (ret)
587 return ret;
588
589 file_dont_truncate(inode);
590 return 0;
591 }
592
f2fs_file_open(struct inode * inode,struct file * filp)593 static int f2fs_file_open(struct inode *inode, struct file *filp)
594 {
595 int err = fscrypt_file_open(inode, filp);
596
597 if (err)
598 return err;
599
600 if (!f2fs_is_compress_backend_ready(inode))
601 return -EOPNOTSUPP;
602
603 err = fsverity_file_open(inode, filp);
604 if (err)
605 return err;
606
607 filp->f_mode |= FMODE_NOWAIT;
608 filp->f_mode |= FMODE_CAN_ODIRECT;
609
610 err = dquot_file_open(inode, filp);
611 if (err)
612 return err;
613
614 return finish_preallocate_blocks(inode);
615 }
616
f2fs_truncate_data_blocks_range(struct dnode_of_data * dn,int count)617 void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
618 {
619 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
620 int nr_free = 0, ofs = dn->ofs_in_node, len = count;
621 __le32 *addr;
622 bool compressed_cluster = false;
623 int cluster_index = 0, valid_blocks = 0;
624 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
625 bool released = !atomic_read(&F2FS_I(dn->inode)->i_compr_blocks);
626
627 addr = get_dnode_addr(dn->inode, dn->node_page) + ofs;
628
629 /* Assumption: truncation starts with cluster */
630 for (; count > 0; count--, addr++, dn->ofs_in_node++, cluster_index++) {
631 block_t blkaddr = le32_to_cpu(*addr);
632
633 if (f2fs_compressed_file(dn->inode) &&
634 !(cluster_index & (cluster_size - 1))) {
635 if (compressed_cluster)
636 f2fs_i_compr_blocks_update(dn->inode,
637 valid_blocks, false);
638 compressed_cluster = (blkaddr == COMPRESS_ADDR);
639 valid_blocks = 0;
640 }
641
642 if (blkaddr == NULL_ADDR)
643 continue;
644
645 f2fs_set_data_blkaddr(dn, NULL_ADDR);
646
647 if (__is_valid_data_blkaddr(blkaddr)) {
648 if (time_to_inject(sbi, FAULT_BLKADDR_CONSISTENCE))
649 continue;
650 if (!f2fs_is_valid_blkaddr_raw(sbi, blkaddr,
651 DATA_GENERIC_ENHANCE))
652 continue;
653 if (compressed_cluster)
654 valid_blocks++;
655 }
656
657 f2fs_invalidate_blocks(sbi, blkaddr);
658
659 if (!released || blkaddr != COMPRESS_ADDR)
660 nr_free++;
661 }
662
663 if (compressed_cluster)
664 f2fs_i_compr_blocks_update(dn->inode, valid_blocks, false);
665
666 if (nr_free) {
667 pgoff_t fofs;
668 /*
669 * once we invalidate valid blkaddr in range [ofs, ofs + count],
670 * we will invalidate all blkaddr in the whole range.
671 */
672 fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page),
673 dn->inode) + ofs;
674 f2fs_update_read_extent_cache_range(dn, fofs, 0, len);
675 f2fs_update_age_extent_cache_range(dn, fofs, len);
676 dec_valid_block_count(sbi, dn->inode, nr_free);
677 }
678 dn->ofs_in_node = ofs;
679
680 f2fs_update_time(sbi, REQ_TIME);
681 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
682 dn->ofs_in_node, nr_free);
683 }
684
truncate_partial_data_page(struct inode * inode,u64 from,bool cache_only)685 static int truncate_partial_data_page(struct inode *inode, u64 from,
686 bool cache_only)
687 {
688 loff_t offset = from & (PAGE_SIZE - 1);
689 pgoff_t index = from >> PAGE_SHIFT;
690 struct address_space *mapping = inode->i_mapping;
691 struct page *page;
692
693 if (!offset && !cache_only)
694 return 0;
695
696 if (cache_only) {
697 page = find_lock_page(mapping, index);
698 if (page && PageUptodate(page))
699 goto truncate_out;
700 f2fs_put_page(page, 1);
701 return 0;
702 }
703
704 page = f2fs_get_lock_data_page(inode, index, true);
705 if (IS_ERR(page))
706 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
707 truncate_out:
708 f2fs_wait_on_page_writeback(page, DATA, true, true);
709 zero_user(page, offset, PAGE_SIZE - offset);
710
711 /* An encrypted inode should have a key and truncate the last page. */
712 f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
713 if (!cache_only)
714 set_page_dirty(page);
715 f2fs_put_page(page, 1);
716 return 0;
717 }
718
f2fs_do_truncate_blocks(struct inode * inode,u64 from,bool lock)719 int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
720 {
721 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
722 struct dnode_of_data dn;
723 pgoff_t free_from;
724 int count = 0, err = 0;
725 struct page *ipage;
726 bool truncate_page = false;
727
728 trace_f2fs_truncate_blocks_enter(inode, from);
729
730 free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
731
732 if (free_from >= max_file_blocks(inode))
733 goto free_partial;
734
735 if (lock)
736 f2fs_lock_op(sbi);
737
738 ipage = f2fs_get_node_page(sbi, inode->i_ino);
739 if (IS_ERR(ipage)) {
740 err = PTR_ERR(ipage);
741 goto out;
742 }
743
744 if (f2fs_has_inline_data(inode)) {
745 f2fs_truncate_inline_inode(inode, ipage, from);
746 f2fs_put_page(ipage, 1);
747 truncate_page = true;
748 goto out;
749 }
750
751 set_new_dnode(&dn, inode, ipage, NULL, 0);
752 err = f2fs_get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
753 if (err) {
754 if (err == -ENOENT)
755 goto free_next;
756 goto out;
757 }
758
759 count = ADDRS_PER_PAGE(dn.node_page, inode);
760
761 count -= dn.ofs_in_node;
762 f2fs_bug_on(sbi, count < 0);
763
764 if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
765 f2fs_truncate_data_blocks_range(&dn, count);
766 free_from += count;
767 }
768
769 f2fs_put_dnode(&dn);
770 free_next:
771 err = f2fs_truncate_inode_blocks(inode, free_from);
772 out:
773 if (lock)
774 f2fs_unlock_op(sbi);
775 free_partial:
776 /* lastly zero out the first data page */
777 if (!err)
778 err = truncate_partial_data_page(inode, from, truncate_page);
779
780 trace_f2fs_truncate_blocks_exit(inode, err);
781 return err;
782 }
783
f2fs_truncate_blocks(struct inode * inode,u64 from,bool lock)784 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
785 {
786 u64 free_from = from;
787 int err;
788
789 #ifdef CONFIG_F2FS_FS_COMPRESSION
790 /*
791 * for compressed file, only support cluster size
792 * aligned truncation.
793 */
794 if (f2fs_compressed_file(inode))
795 free_from = round_up(from,
796 F2FS_I(inode)->i_cluster_size << PAGE_SHIFT);
797 #endif
798
799 err = f2fs_do_truncate_blocks(inode, free_from, lock);
800 if (err)
801 return err;
802
803 #ifdef CONFIG_F2FS_FS_COMPRESSION
804 /*
805 * For compressed file, after release compress blocks, don't allow write
806 * direct, but we should allow write direct after truncate to zero.
807 */
808 if (f2fs_compressed_file(inode) && !free_from
809 && is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
810 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
811
812 if (from != free_from) {
813 err = f2fs_truncate_partial_cluster(inode, from, lock);
814 if (err)
815 return err;
816 }
817 #endif
818
819 return 0;
820 }
821
f2fs_truncate(struct inode * inode)822 int f2fs_truncate(struct inode *inode)
823 {
824 int err;
825
826 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
827 return -EIO;
828
829 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
830 S_ISLNK(inode->i_mode)))
831 return 0;
832
833 trace_f2fs_truncate(inode);
834
835 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE))
836 return -EIO;
837
838 err = f2fs_dquot_initialize(inode);
839 if (err)
840 return err;
841
842 /* we should check inline_data size */
843 if (!f2fs_may_inline_data(inode)) {
844 err = f2fs_convert_inline_inode(inode);
845 if (err)
846 return err;
847 }
848
849 err = f2fs_truncate_blocks(inode, i_size_read(inode), true);
850 if (err)
851 return err;
852
853 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
854 f2fs_mark_inode_dirty_sync(inode, false);
855 return 0;
856 }
857
f2fs_force_buffered_io(struct inode * inode,int rw)858 static bool f2fs_force_buffered_io(struct inode *inode, int rw)
859 {
860 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
861
862 if (!fscrypt_dio_supported(inode))
863 return true;
864 if (fsverity_active(inode))
865 return true;
866 if (f2fs_compressed_file(inode))
867 return true;
868 if (f2fs_has_inline_data(inode))
869 return true;
870
871 /* disallow direct IO if any of devices has unaligned blksize */
872 if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize)
873 return true;
874 /*
875 * for blkzoned device, fallback direct IO to buffered IO, so
876 * all IOs can be serialized by log-structured write.
877 */
878 if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE) &&
879 !f2fs_is_pinned_file(inode))
880 return true;
881 if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))
882 return true;
883
884 return false;
885 }
886
f2fs_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)887 int f2fs_getattr(struct mnt_idmap *idmap, const struct path *path,
888 struct kstat *stat, u32 request_mask, unsigned int query_flags)
889 {
890 struct inode *inode = d_inode(path->dentry);
891 struct f2fs_inode_info *fi = F2FS_I(inode);
892 struct f2fs_inode *ri = NULL;
893 unsigned int flags;
894
895 if (f2fs_has_extra_attr(inode) &&
896 f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
897 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
898 stat->result_mask |= STATX_BTIME;
899 stat->btime.tv_sec = fi->i_crtime.tv_sec;
900 stat->btime.tv_nsec = fi->i_crtime.tv_nsec;
901 }
902
903 /*
904 * Return the DIO alignment restrictions if requested. We only return
905 * this information when requested, since on encrypted files it might
906 * take a fair bit of work to get if the file wasn't opened recently.
907 *
908 * f2fs sometimes supports DIO reads but not DIO writes. STATX_DIOALIGN
909 * cannot represent that, so in that case we report no DIO support.
910 */
911 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->i_mode)) {
912 unsigned int bsize = i_blocksize(inode);
913
914 stat->result_mask |= STATX_DIOALIGN;
915 if (!f2fs_force_buffered_io(inode, WRITE)) {
916 stat->dio_mem_align = bsize;
917 stat->dio_offset_align = bsize;
918 }
919 }
920
921 flags = fi->i_flags;
922 if (flags & F2FS_COMPR_FL)
923 stat->attributes |= STATX_ATTR_COMPRESSED;
924 if (flags & F2FS_APPEND_FL)
925 stat->attributes |= STATX_ATTR_APPEND;
926 if (IS_ENCRYPTED(inode))
927 stat->attributes |= STATX_ATTR_ENCRYPTED;
928 if (flags & F2FS_IMMUTABLE_FL)
929 stat->attributes |= STATX_ATTR_IMMUTABLE;
930 if (flags & F2FS_NODUMP_FL)
931 stat->attributes |= STATX_ATTR_NODUMP;
932 if (IS_VERITY(inode))
933 stat->attributes |= STATX_ATTR_VERITY;
934
935 stat->attributes_mask |= (STATX_ATTR_COMPRESSED |
936 STATX_ATTR_APPEND |
937 STATX_ATTR_ENCRYPTED |
938 STATX_ATTR_IMMUTABLE |
939 STATX_ATTR_NODUMP |
940 STATX_ATTR_VERITY);
941
942 generic_fillattr(idmap, request_mask, inode, stat);
943
944 /* we need to show initial sectors used for inline_data/dentries */
945 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
946 f2fs_has_inline_dentry(inode))
947 stat->blocks += (stat->size + 511) >> 9;
948
949 return 0;
950 }
951
952 #ifdef CONFIG_F2FS_FS_POSIX_ACL
__setattr_copy(struct mnt_idmap * idmap,struct inode * inode,const struct iattr * attr)953 static void __setattr_copy(struct mnt_idmap *idmap,
954 struct inode *inode, const struct iattr *attr)
955 {
956 unsigned int ia_valid = attr->ia_valid;
957
958 i_uid_update(idmap, attr, inode);
959 i_gid_update(idmap, attr, inode);
960 if (ia_valid & ATTR_ATIME)
961 inode_set_atime_to_ts(inode, attr->ia_atime);
962 if (ia_valid & ATTR_MTIME)
963 inode_set_mtime_to_ts(inode, attr->ia_mtime);
964 if (ia_valid & ATTR_CTIME)
965 inode_set_ctime_to_ts(inode, attr->ia_ctime);
966 if (ia_valid & ATTR_MODE) {
967 umode_t mode = attr->ia_mode;
968
969 if (!in_group_or_capable(idmap, inode, i_gid_into_vfsgid(idmap, inode)))
970 mode &= ~S_ISGID;
971 set_acl_inode(inode, mode);
972 }
973 }
974 #else
975 #define __setattr_copy setattr_copy
976 #endif
977
f2fs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)978 int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
979 struct iattr *attr)
980 {
981 struct inode *inode = d_inode(dentry);
982 struct f2fs_inode_info *fi = F2FS_I(inode);
983 int err;
984
985 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
986 return -EIO;
987
988 if (unlikely(IS_IMMUTABLE(inode)))
989 return -EPERM;
990
991 if (unlikely(IS_APPEND(inode) &&
992 (attr->ia_valid & (ATTR_MODE | ATTR_UID |
993 ATTR_GID | ATTR_TIMES_SET))))
994 return -EPERM;
995
996 if ((attr->ia_valid & ATTR_SIZE)) {
997 if (!f2fs_is_compress_backend_ready(inode))
998 return -EOPNOTSUPP;
999 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
1000 !IS_ALIGNED(attr->ia_size,
1001 F2FS_BLK_TO_BYTES(fi->i_cluster_size)))
1002 return -EINVAL;
1003 }
1004
1005 err = setattr_prepare(idmap, dentry, attr);
1006 if (err)
1007 return err;
1008
1009 err = fscrypt_prepare_setattr(dentry, attr);
1010 if (err)
1011 return err;
1012
1013 err = fsverity_prepare_setattr(dentry, attr);
1014 if (err)
1015 return err;
1016
1017 if (is_quota_modification(idmap, inode, attr)) {
1018 err = f2fs_dquot_initialize(inode);
1019 if (err)
1020 return err;
1021 }
1022 if (i_uid_needs_update(idmap, attr, inode) ||
1023 i_gid_needs_update(idmap, attr, inode)) {
1024 f2fs_lock_op(F2FS_I_SB(inode));
1025 err = dquot_transfer(idmap, inode, attr);
1026 if (err) {
1027 set_sbi_flag(F2FS_I_SB(inode),
1028 SBI_QUOTA_NEED_REPAIR);
1029 f2fs_unlock_op(F2FS_I_SB(inode));
1030 return err;
1031 }
1032 /*
1033 * update uid/gid under lock_op(), so that dquot and inode can
1034 * be updated atomically.
1035 */
1036 i_uid_update(idmap, attr, inode);
1037 i_gid_update(idmap, attr, inode);
1038 f2fs_mark_inode_dirty_sync(inode, true);
1039 f2fs_unlock_op(F2FS_I_SB(inode));
1040 }
1041
1042 if (attr->ia_valid & ATTR_SIZE) {
1043 loff_t old_size = i_size_read(inode);
1044
1045 if (attr->ia_size > MAX_INLINE_DATA(inode)) {
1046 /*
1047 * should convert inline inode before i_size_write to
1048 * keep smaller than inline_data size with inline flag.
1049 */
1050 err = f2fs_convert_inline_inode(inode);
1051 if (err)
1052 return err;
1053 }
1054
1055 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
1056 filemap_invalidate_lock(inode->i_mapping);
1057
1058 truncate_setsize(inode, attr->ia_size);
1059
1060 if (attr->ia_size <= old_size)
1061 err = f2fs_truncate(inode);
1062 /*
1063 * do not trim all blocks after i_size if target size is
1064 * larger than i_size.
1065 */
1066 filemap_invalidate_unlock(inode->i_mapping);
1067 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
1068 if (err)
1069 return err;
1070
1071 spin_lock(&fi->i_size_lock);
1072 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1073 fi->last_disk_size = i_size_read(inode);
1074 spin_unlock(&fi->i_size_lock);
1075 }
1076
1077 __setattr_copy(idmap, inode, attr);
1078
1079 if (attr->ia_valid & ATTR_MODE) {
1080 err = posix_acl_chmod(idmap, dentry, f2fs_get_inode_mode(inode));
1081
1082 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
1083 if (!err)
1084 inode->i_mode = fi->i_acl_mode;
1085 clear_inode_flag(inode, FI_ACL_MODE);
1086 }
1087 }
1088
1089 /* file size may changed here */
1090 f2fs_mark_inode_dirty_sync(inode, true);
1091
1092 /* inode change will produce dirty node pages flushed by checkpoint */
1093 f2fs_balance_fs(F2FS_I_SB(inode), true);
1094
1095 return err;
1096 }
1097
1098 const struct inode_operations f2fs_file_inode_operations = {
1099 .getattr = f2fs_getattr,
1100 .setattr = f2fs_setattr,
1101 .get_inode_acl = f2fs_get_acl,
1102 .set_acl = f2fs_set_acl,
1103 .listxattr = f2fs_listxattr,
1104 .fiemap = f2fs_fiemap,
1105 .fileattr_get = f2fs_fileattr_get,
1106 .fileattr_set = f2fs_fileattr_set,
1107 };
1108
fill_zero(struct inode * inode,pgoff_t index,loff_t start,loff_t len)1109 static int fill_zero(struct inode *inode, pgoff_t index,
1110 loff_t start, loff_t len)
1111 {
1112 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1113 struct page *page;
1114
1115 if (!len)
1116 return 0;
1117
1118 f2fs_balance_fs(sbi, true);
1119
1120 f2fs_lock_op(sbi);
1121 page = f2fs_get_new_data_page(inode, NULL, index, false);
1122 f2fs_unlock_op(sbi);
1123
1124 if (IS_ERR(page))
1125 return PTR_ERR(page);
1126
1127 f2fs_wait_on_page_writeback(page, DATA, true, true);
1128 zero_user(page, start, len);
1129 set_page_dirty(page);
1130 f2fs_put_page(page, 1);
1131 return 0;
1132 }
1133
f2fs_truncate_hole(struct inode * inode,pgoff_t pg_start,pgoff_t pg_end)1134 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
1135 {
1136 int err;
1137
1138 while (pg_start < pg_end) {
1139 struct dnode_of_data dn;
1140 pgoff_t end_offset, count;
1141
1142 set_new_dnode(&dn, inode, NULL, NULL, 0);
1143 err = f2fs_get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
1144 if (err) {
1145 if (err == -ENOENT) {
1146 pg_start = f2fs_get_next_page_offset(&dn,
1147 pg_start);
1148 continue;
1149 }
1150 return err;
1151 }
1152
1153 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1154 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
1155
1156 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
1157
1158 f2fs_truncate_data_blocks_range(&dn, count);
1159 f2fs_put_dnode(&dn);
1160
1161 pg_start += count;
1162 }
1163 return 0;
1164 }
1165
f2fs_punch_hole(struct inode * inode,loff_t offset,loff_t len)1166 static int f2fs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
1167 {
1168 pgoff_t pg_start, pg_end;
1169 loff_t off_start, off_end;
1170 int ret;
1171
1172 ret = f2fs_convert_inline_inode(inode);
1173 if (ret)
1174 return ret;
1175
1176 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1177 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1178
1179 off_start = offset & (PAGE_SIZE - 1);
1180 off_end = (offset + len) & (PAGE_SIZE - 1);
1181
1182 if (pg_start == pg_end) {
1183 ret = fill_zero(inode, pg_start, off_start,
1184 off_end - off_start);
1185 if (ret)
1186 return ret;
1187 } else {
1188 if (off_start) {
1189 ret = fill_zero(inode, pg_start++, off_start,
1190 PAGE_SIZE - off_start);
1191 if (ret)
1192 return ret;
1193 }
1194 if (off_end) {
1195 ret = fill_zero(inode, pg_end, 0, off_end);
1196 if (ret)
1197 return ret;
1198 }
1199
1200 if (pg_start < pg_end) {
1201 loff_t blk_start, blk_end;
1202 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1203
1204 f2fs_balance_fs(sbi, true);
1205
1206 blk_start = (loff_t)pg_start << PAGE_SHIFT;
1207 blk_end = (loff_t)pg_end << PAGE_SHIFT;
1208
1209 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1210 filemap_invalidate_lock(inode->i_mapping);
1211
1212 truncate_pagecache_range(inode, blk_start, blk_end - 1);
1213
1214 f2fs_lock_op(sbi);
1215 ret = f2fs_truncate_hole(inode, pg_start, pg_end);
1216 f2fs_unlock_op(sbi);
1217
1218 filemap_invalidate_unlock(inode->i_mapping);
1219 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1220 }
1221 }
1222
1223 return ret;
1224 }
1225
__read_out_blkaddrs(struct inode * inode,block_t * blkaddr,int * do_replace,pgoff_t off,pgoff_t len)1226 static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
1227 int *do_replace, pgoff_t off, pgoff_t len)
1228 {
1229 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1230 struct dnode_of_data dn;
1231 int ret, done, i;
1232
1233 next_dnode:
1234 set_new_dnode(&dn, inode, NULL, NULL, 0);
1235 ret = f2fs_get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
1236 if (ret && ret != -ENOENT) {
1237 return ret;
1238 } else if (ret == -ENOENT) {
1239 if (dn.max_level == 0)
1240 return -ENOENT;
1241 done = min((pgoff_t)ADDRS_PER_BLOCK(inode) -
1242 dn.ofs_in_node, len);
1243 blkaddr += done;
1244 do_replace += done;
1245 goto next;
1246 }
1247
1248 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
1249 dn.ofs_in_node, len);
1250 for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
1251 *blkaddr = f2fs_data_blkaddr(&dn);
1252
1253 if (__is_valid_data_blkaddr(*blkaddr) &&
1254 !f2fs_is_valid_blkaddr(sbi, *blkaddr,
1255 DATA_GENERIC_ENHANCE)) {
1256 f2fs_put_dnode(&dn);
1257 return -EFSCORRUPTED;
1258 }
1259
1260 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) {
1261
1262 if (f2fs_lfs_mode(sbi)) {
1263 f2fs_put_dnode(&dn);
1264 return -EOPNOTSUPP;
1265 }
1266
1267 /* do not invalidate this block address */
1268 f2fs_update_data_blkaddr(&dn, NULL_ADDR);
1269 *do_replace = 1;
1270 }
1271 }
1272 f2fs_put_dnode(&dn);
1273 next:
1274 len -= done;
1275 off += done;
1276 if (len)
1277 goto next_dnode;
1278 return 0;
1279 }
1280
__roll_back_blkaddrs(struct inode * inode,block_t * blkaddr,int * do_replace,pgoff_t off,int len)1281 static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
1282 int *do_replace, pgoff_t off, int len)
1283 {
1284 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1285 struct dnode_of_data dn;
1286 int ret, i;
1287
1288 for (i = 0; i < len; i++, do_replace++, blkaddr++) {
1289 if (*do_replace == 0)
1290 continue;
1291
1292 set_new_dnode(&dn, inode, NULL, NULL, 0);
1293 ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
1294 if (ret) {
1295 dec_valid_block_count(sbi, inode, 1);
1296 f2fs_invalidate_blocks(sbi, *blkaddr);
1297 } else {
1298 f2fs_update_data_blkaddr(&dn, *blkaddr);
1299 }
1300 f2fs_put_dnode(&dn);
1301 }
1302 return 0;
1303 }
1304
__clone_blkaddrs(struct inode * src_inode,struct inode * dst_inode,block_t * blkaddr,int * do_replace,pgoff_t src,pgoff_t dst,pgoff_t len,bool full)1305 static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
1306 block_t *blkaddr, int *do_replace,
1307 pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
1308 {
1309 struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
1310 pgoff_t i = 0;
1311 int ret;
1312
1313 while (i < len) {
1314 if (blkaddr[i] == NULL_ADDR && !full) {
1315 i++;
1316 continue;
1317 }
1318
1319 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
1320 struct dnode_of_data dn;
1321 struct node_info ni;
1322 size_t new_size;
1323 pgoff_t ilen;
1324
1325 set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
1326 ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
1327 if (ret)
1328 return ret;
1329
1330 ret = f2fs_get_node_info(sbi, dn.nid, &ni, false);
1331 if (ret) {
1332 f2fs_put_dnode(&dn);
1333 return ret;
1334 }
1335
1336 ilen = min((pgoff_t)
1337 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
1338 dn.ofs_in_node, len - i);
1339 do {
1340 dn.data_blkaddr = f2fs_data_blkaddr(&dn);
1341 f2fs_truncate_data_blocks_range(&dn, 1);
1342
1343 if (do_replace[i]) {
1344 f2fs_i_blocks_write(src_inode,
1345 1, false, false);
1346 f2fs_i_blocks_write(dst_inode,
1347 1, true, false);
1348 f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
1349 blkaddr[i], ni.version, true, false);
1350
1351 do_replace[i] = 0;
1352 }
1353 dn.ofs_in_node++;
1354 i++;
1355 new_size = (loff_t)(dst + i) << PAGE_SHIFT;
1356 if (dst_inode->i_size < new_size)
1357 f2fs_i_size_write(dst_inode, new_size);
1358 } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
1359
1360 f2fs_put_dnode(&dn);
1361 } else {
1362 struct page *psrc, *pdst;
1363
1364 psrc = f2fs_get_lock_data_page(src_inode,
1365 src + i, true);
1366 if (IS_ERR(psrc))
1367 return PTR_ERR(psrc);
1368 pdst = f2fs_get_new_data_page(dst_inode, NULL, dst + i,
1369 true);
1370 if (IS_ERR(pdst)) {
1371 f2fs_put_page(psrc, 1);
1372 return PTR_ERR(pdst);
1373 }
1374
1375 f2fs_wait_on_page_writeback(pdst, DATA, true, true);
1376
1377 memcpy_page(pdst, 0, psrc, 0, PAGE_SIZE);
1378 set_page_dirty(pdst);
1379 set_page_private_gcing(pdst);
1380 f2fs_put_page(pdst, 1);
1381 f2fs_put_page(psrc, 1);
1382
1383 ret = f2fs_truncate_hole(src_inode,
1384 src + i, src + i + 1);
1385 if (ret)
1386 return ret;
1387 i++;
1388 }
1389 }
1390 return 0;
1391 }
1392
__exchange_data_block(struct inode * src_inode,struct inode * dst_inode,pgoff_t src,pgoff_t dst,pgoff_t len,bool full)1393 static int __exchange_data_block(struct inode *src_inode,
1394 struct inode *dst_inode, pgoff_t src, pgoff_t dst,
1395 pgoff_t len, bool full)
1396 {
1397 block_t *src_blkaddr;
1398 int *do_replace;
1399 pgoff_t olen;
1400 int ret;
1401
1402 while (len) {
1403 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK(src_inode), len);
1404
1405 src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1406 array_size(olen, sizeof(block_t)),
1407 GFP_NOFS);
1408 if (!src_blkaddr)
1409 return -ENOMEM;
1410
1411 do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode),
1412 array_size(olen, sizeof(int)),
1413 GFP_NOFS);
1414 if (!do_replace) {
1415 kvfree(src_blkaddr);
1416 return -ENOMEM;
1417 }
1418
1419 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1420 do_replace, src, olen);
1421 if (ret)
1422 goto roll_back;
1423
1424 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1425 do_replace, src, dst, olen, full);
1426 if (ret)
1427 goto roll_back;
1428
1429 src += olen;
1430 dst += olen;
1431 len -= olen;
1432
1433 kvfree(src_blkaddr);
1434 kvfree(do_replace);
1435 }
1436 return 0;
1437
1438 roll_back:
1439 __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, olen);
1440 kvfree(src_blkaddr);
1441 kvfree(do_replace);
1442 return ret;
1443 }
1444
f2fs_do_collapse(struct inode * inode,loff_t offset,loff_t len)1445 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
1446 {
1447 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1448 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1449 pgoff_t start = offset >> PAGE_SHIFT;
1450 pgoff_t end = (offset + len) >> PAGE_SHIFT;
1451 int ret;
1452
1453 f2fs_balance_fs(sbi, true);
1454
1455 /* avoid gc operation during block exchange */
1456 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1457 filemap_invalidate_lock(inode->i_mapping);
1458
1459 f2fs_lock_op(sbi);
1460 f2fs_drop_extent_tree(inode);
1461 truncate_pagecache(inode, offset);
1462 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1463 f2fs_unlock_op(sbi);
1464
1465 filemap_invalidate_unlock(inode->i_mapping);
1466 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1467 return ret;
1468 }
1469
f2fs_collapse_range(struct inode * inode,loff_t offset,loff_t len)1470 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1471 {
1472 loff_t new_size;
1473 int ret;
1474
1475 if (offset + len >= i_size_read(inode))
1476 return -EINVAL;
1477
1478 /* collapse range should be aligned to block size of f2fs. */
1479 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1480 return -EINVAL;
1481
1482 ret = f2fs_convert_inline_inode(inode);
1483 if (ret)
1484 return ret;
1485
1486 /* write out all dirty pages from offset */
1487 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1488 if (ret)
1489 return ret;
1490
1491 ret = f2fs_do_collapse(inode, offset, len);
1492 if (ret)
1493 return ret;
1494
1495 /* write out all moved pages, if possible */
1496 filemap_invalidate_lock(inode->i_mapping);
1497 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1498 truncate_pagecache(inode, offset);
1499
1500 new_size = i_size_read(inode) - len;
1501 ret = f2fs_truncate_blocks(inode, new_size, true);
1502 filemap_invalidate_unlock(inode->i_mapping);
1503 if (!ret)
1504 f2fs_i_size_write(inode, new_size);
1505 return ret;
1506 }
1507
f2fs_do_zero_range(struct dnode_of_data * dn,pgoff_t start,pgoff_t end)1508 static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
1509 pgoff_t end)
1510 {
1511 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
1512 pgoff_t index = start;
1513 unsigned int ofs_in_node = dn->ofs_in_node;
1514 blkcnt_t count = 0;
1515 int ret;
1516
1517 for (; index < end; index++, dn->ofs_in_node++) {
1518 if (f2fs_data_blkaddr(dn) == NULL_ADDR)
1519 count++;
1520 }
1521
1522 dn->ofs_in_node = ofs_in_node;
1523 ret = f2fs_reserve_new_blocks(dn, count);
1524 if (ret)
1525 return ret;
1526
1527 dn->ofs_in_node = ofs_in_node;
1528 for (index = start; index < end; index++, dn->ofs_in_node++) {
1529 dn->data_blkaddr = f2fs_data_blkaddr(dn);
1530 /*
1531 * f2fs_reserve_new_blocks will not guarantee entire block
1532 * allocation.
1533 */
1534 if (dn->data_blkaddr == NULL_ADDR) {
1535 ret = -ENOSPC;
1536 break;
1537 }
1538
1539 if (dn->data_blkaddr == NEW_ADDR)
1540 continue;
1541
1542 if (!f2fs_is_valid_blkaddr(sbi, dn->data_blkaddr,
1543 DATA_GENERIC_ENHANCE)) {
1544 ret = -EFSCORRUPTED;
1545 break;
1546 }
1547
1548 f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
1549 f2fs_set_data_blkaddr(dn, NEW_ADDR);
1550 }
1551
1552 f2fs_update_read_extent_cache_range(dn, start, 0, index - start);
1553 f2fs_update_age_extent_cache_range(dn, start, index - start);
1554
1555 return ret;
1556 }
1557
f2fs_zero_range(struct inode * inode,loff_t offset,loff_t len,int mode)1558 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1559 int mode)
1560 {
1561 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1562 struct address_space *mapping = inode->i_mapping;
1563 pgoff_t index, pg_start, pg_end;
1564 loff_t new_size = i_size_read(inode);
1565 loff_t off_start, off_end;
1566 int ret = 0;
1567
1568 ret = inode_newsize_ok(inode, (len + offset));
1569 if (ret)
1570 return ret;
1571
1572 ret = f2fs_convert_inline_inode(inode);
1573 if (ret)
1574 return ret;
1575
1576 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1577 if (ret)
1578 return ret;
1579
1580 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1581 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
1582
1583 off_start = offset & (PAGE_SIZE - 1);
1584 off_end = (offset + len) & (PAGE_SIZE - 1);
1585
1586 if (pg_start == pg_end) {
1587 ret = fill_zero(inode, pg_start, off_start,
1588 off_end - off_start);
1589 if (ret)
1590 return ret;
1591
1592 new_size = max_t(loff_t, new_size, offset + len);
1593 } else {
1594 if (off_start) {
1595 ret = fill_zero(inode, pg_start++, off_start,
1596 PAGE_SIZE - off_start);
1597 if (ret)
1598 return ret;
1599
1600 new_size = max_t(loff_t, new_size,
1601 (loff_t)pg_start << PAGE_SHIFT);
1602 }
1603
1604 for (index = pg_start; index < pg_end;) {
1605 struct dnode_of_data dn;
1606 unsigned int end_offset;
1607 pgoff_t end;
1608
1609 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1610 filemap_invalidate_lock(mapping);
1611
1612 truncate_pagecache_range(inode,
1613 (loff_t)index << PAGE_SHIFT,
1614 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1615
1616 f2fs_lock_op(sbi);
1617
1618 set_new_dnode(&dn, inode, NULL, NULL, 0);
1619 ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
1620 if (ret) {
1621 f2fs_unlock_op(sbi);
1622 filemap_invalidate_unlock(mapping);
1623 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1624 goto out;
1625 }
1626
1627 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1628 end = min(pg_end, end_offset - dn.ofs_in_node + index);
1629
1630 ret = f2fs_do_zero_range(&dn, index, end);
1631 f2fs_put_dnode(&dn);
1632
1633 f2fs_unlock_op(sbi);
1634 filemap_invalidate_unlock(mapping);
1635 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1636
1637 f2fs_balance_fs(sbi, dn.node_changed);
1638
1639 if (ret)
1640 goto out;
1641
1642 index = end;
1643 new_size = max_t(loff_t, new_size,
1644 (loff_t)index << PAGE_SHIFT);
1645 }
1646
1647 if (off_end) {
1648 ret = fill_zero(inode, pg_end, 0, off_end);
1649 if (ret)
1650 goto out;
1651
1652 new_size = max_t(loff_t, new_size, offset + len);
1653 }
1654 }
1655
1656 out:
1657 if (new_size > i_size_read(inode)) {
1658 if (mode & FALLOC_FL_KEEP_SIZE)
1659 file_set_keep_isize(inode);
1660 else
1661 f2fs_i_size_write(inode, new_size);
1662 }
1663 return ret;
1664 }
1665
f2fs_insert_range(struct inode * inode,loff_t offset,loff_t len)1666 static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1667 {
1668 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1669 struct address_space *mapping = inode->i_mapping;
1670 pgoff_t nr, pg_start, pg_end, delta, idx;
1671 loff_t new_size;
1672 int ret = 0;
1673
1674 new_size = i_size_read(inode) + len;
1675 ret = inode_newsize_ok(inode, new_size);
1676 if (ret)
1677 return ret;
1678
1679 if (offset >= i_size_read(inode))
1680 return -EINVAL;
1681
1682 /* insert range should be aligned to block size of f2fs. */
1683 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1684 return -EINVAL;
1685
1686 ret = f2fs_convert_inline_inode(inode);
1687 if (ret)
1688 return ret;
1689
1690 f2fs_balance_fs(sbi, true);
1691
1692 filemap_invalidate_lock(mapping);
1693 ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);
1694 filemap_invalidate_unlock(mapping);
1695 if (ret)
1696 return ret;
1697
1698 /* write out all dirty pages from offset */
1699 ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1700 if (ret)
1701 return ret;
1702
1703 pg_start = offset >> PAGE_SHIFT;
1704 pg_end = (offset + len) >> PAGE_SHIFT;
1705 delta = pg_end - pg_start;
1706 idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
1707
1708 /* avoid gc operation during block exchange */
1709 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1710 filemap_invalidate_lock(mapping);
1711 truncate_pagecache(inode, offset);
1712
1713 while (!ret && idx > pg_start) {
1714 nr = idx - pg_start;
1715 if (nr > delta)
1716 nr = delta;
1717 idx -= nr;
1718
1719 f2fs_lock_op(sbi);
1720 f2fs_drop_extent_tree(inode);
1721
1722 ret = __exchange_data_block(inode, inode, idx,
1723 idx + delta, nr, false);
1724 f2fs_unlock_op(sbi);
1725 }
1726 filemap_invalidate_unlock(mapping);
1727 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1728 if (ret)
1729 return ret;
1730
1731 /* write out all moved pages, if possible */
1732 filemap_invalidate_lock(mapping);
1733 ret = filemap_write_and_wait_range(mapping, offset, LLONG_MAX);
1734 truncate_pagecache(inode, offset);
1735 filemap_invalidate_unlock(mapping);
1736
1737 if (!ret)
1738 f2fs_i_size_write(inode, new_size);
1739 return ret;
1740 }
1741
f2fs_expand_inode_data(struct inode * inode,loff_t offset,loff_t len,int mode)1742 static int f2fs_expand_inode_data(struct inode *inode, loff_t offset,
1743 loff_t len, int mode)
1744 {
1745 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1746 struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
1747 .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE,
1748 .m_may_create = true };
1749 struct f2fs_gc_control gc_control = { .victim_segno = NULL_SEGNO,
1750 .init_gc_type = FG_GC,
1751 .should_migrate_blocks = false,
1752 .err_gc_skipped = true,
1753 .nr_free_secs = 0 };
1754 pgoff_t pg_start, pg_end;
1755 loff_t new_size;
1756 loff_t off_end;
1757 block_t expanded = 0;
1758 int err;
1759
1760 err = inode_newsize_ok(inode, (len + offset));
1761 if (err)
1762 return err;
1763
1764 err = f2fs_convert_inline_inode(inode);
1765 if (err)
1766 return err;
1767
1768 f2fs_balance_fs(sbi, true);
1769
1770 pg_start = ((unsigned long long)offset) >> PAGE_SHIFT;
1771 pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
1772 off_end = (offset + len) & (PAGE_SIZE - 1);
1773
1774 map.m_lblk = pg_start;
1775 map.m_len = pg_end - pg_start;
1776 if (off_end)
1777 map.m_len++;
1778
1779 if (!map.m_len)
1780 return 0;
1781
1782 if (f2fs_is_pinned_file(inode)) {
1783 block_t sec_blks = CAP_BLKS_PER_SEC(sbi);
1784 block_t sec_len = roundup(map.m_len, sec_blks);
1785
1786 map.m_len = sec_blks;
1787 next_alloc:
1788 if (has_not_enough_free_secs(sbi, 0,
1789 GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi)))) {
1790 f2fs_down_write(&sbi->gc_lock);
1791 stat_inc_gc_call_count(sbi, FOREGROUND);
1792 err = f2fs_gc(sbi, &gc_control);
1793 if (err && err != -ENODATA)
1794 goto out_err;
1795 }
1796
1797 f2fs_down_write(&sbi->pin_sem);
1798
1799 err = f2fs_allocate_pinning_section(sbi);
1800 if (err) {
1801 f2fs_up_write(&sbi->pin_sem);
1802 goto out_err;
1803 }
1804
1805 map.m_seg_type = CURSEG_COLD_DATA_PINNED;
1806 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_DIO);
1807 file_dont_truncate(inode);
1808
1809 f2fs_up_write(&sbi->pin_sem);
1810
1811 expanded += map.m_len;
1812 sec_len -= map.m_len;
1813 map.m_lblk += map.m_len;
1814 if (!err && sec_len)
1815 goto next_alloc;
1816
1817 map.m_len = expanded;
1818 } else {
1819 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
1820 expanded = map.m_len;
1821 }
1822 out_err:
1823 if (err) {
1824 pgoff_t last_off;
1825
1826 if (!expanded)
1827 return err;
1828
1829 last_off = pg_start + expanded - 1;
1830
1831 /* update new size to the failed position */
1832 new_size = (last_off == pg_end) ? offset + len :
1833 (loff_t)(last_off + 1) << PAGE_SHIFT;
1834 } else {
1835 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
1836 }
1837
1838 if (new_size > i_size_read(inode)) {
1839 if (mode & FALLOC_FL_KEEP_SIZE)
1840 file_set_keep_isize(inode);
1841 else
1842 f2fs_i_size_write(inode, new_size);
1843 }
1844
1845 return err;
1846 }
1847
f2fs_fallocate(struct file * file,int mode,loff_t offset,loff_t len)1848 static long f2fs_fallocate(struct file *file, int mode,
1849 loff_t offset, loff_t len)
1850 {
1851 struct inode *inode = file_inode(file);
1852 long ret = 0;
1853
1854 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
1855 return -EIO;
1856 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
1857 return -ENOSPC;
1858 if (!f2fs_is_compress_backend_ready(inode))
1859 return -EOPNOTSUPP;
1860
1861 /* f2fs only support ->fallocate for regular file */
1862 if (!S_ISREG(inode->i_mode))
1863 return -EINVAL;
1864
1865 if (IS_ENCRYPTED(inode) &&
1866 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
1867 return -EOPNOTSUPP;
1868
1869 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1870 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1871 FALLOC_FL_INSERT_RANGE))
1872 return -EOPNOTSUPP;
1873
1874 inode_lock(inode);
1875
1876 /*
1877 * Pinned file should not support partial truncation since the block
1878 * can be used by applications.
1879 */
1880 if ((f2fs_compressed_file(inode) || f2fs_is_pinned_file(inode)) &&
1881 (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE |
1882 FALLOC_FL_ZERO_RANGE | FALLOC_FL_INSERT_RANGE))) {
1883 ret = -EOPNOTSUPP;
1884 goto out;
1885 }
1886
1887 ret = file_modified(file);
1888 if (ret)
1889 goto out;
1890
1891 if (mode & FALLOC_FL_PUNCH_HOLE) {
1892 if (offset >= inode->i_size)
1893 goto out;
1894
1895 ret = f2fs_punch_hole(inode, offset, len);
1896 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1897 ret = f2fs_collapse_range(inode, offset, len);
1898 } else if (mode & FALLOC_FL_ZERO_RANGE) {
1899 ret = f2fs_zero_range(inode, offset, len, mode);
1900 } else if (mode & FALLOC_FL_INSERT_RANGE) {
1901 ret = f2fs_insert_range(inode, offset, len);
1902 } else {
1903 ret = f2fs_expand_inode_data(inode, offset, len, mode);
1904 }
1905
1906 if (!ret) {
1907 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1908 f2fs_mark_inode_dirty_sync(inode, false);
1909 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1910 }
1911
1912 out:
1913 inode_unlock(inode);
1914
1915 trace_f2fs_fallocate(inode, mode, offset, len, ret);
1916 return ret;
1917 }
1918
f2fs_release_file(struct inode * inode,struct file * filp)1919 static int f2fs_release_file(struct inode *inode, struct file *filp)
1920 {
1921 /*
1922 * f2fs_release_file is called at every close calls. So we should
1923 * not drop any inmemory pages by close called by other process.
1924 */
1925 if (!(filp->f_mode & FMODE_WRITE) ||
1926 atomic_read(&inode->i_writecount) != 1)
1927 return 0;
1928
1929 inode_lock(inode);
1930 f2fs_abort_atomic_write(inode, true);
1931 inode_unlock(inode);
1932
1933 return 0;
1934 }
1935
f2fs_file_flush(struct file * file,fl_owner_t id)1936 static int f2fs_file_flush(struct file *file, fl_owner_t id)
1937 {
1938 struct inode *inode = file_inode(file);
1939
1940 /*
1941 * If the process doing a transaction is crashed, we should do
1942 * roll-back. Otherwise, other reader/write can see corrupted database
1943 * until all the writers close its file. Since this should be done
1944 * before dropping file lock, it needs to do in ->flush.
1945 */
1946 if (F2FS_I(inode)->atomic_write_task == current &&
1947 (current->flags & PF_EXITING)) {
1948 inode_lock(inode);
1949 f2fs_abort_atomic_write(inode, true);
1950 inode_unlock(inode);
1951 }
1952
1953 return 0;
1954 }
1955
f2fs_setflags_common(struct inode * inode,u32 iflags,u32 mask)1956 static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
1957 {
1958 struct f2fs_inode_info *fi = F2FS_I(inode);
1959 u32 masked_flags = fi->i_flags & mask;
1960
1961 /* mask can be shrunk by flags_valid selector */
1962 iflags &= mask;
1963
1964 /* Is it quota file? Do not allow user to mess with it */
1965 if (IS_NOQUOTA(inode))
1966 return -EPERM;
1967
1968 if ((iflags ^ masked_flags) & F2FS_CASEFOLD_FL) {
1969 if (!f2fs_sb_has_casefold(F2FS_I_SB(inode)))
1970 return -EOPNOTSUPP;
1971 if (!f2fs_empty_dir(inode))
1972 return -ENOTEMPTY;
1973 }
1974
1975 if (iflags & (F2FS_COMPR_FL | F2FS_NOCOMP_FL)) {
1976 if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
1977 return -EOPNOTSUPP;
1978 if ((iflags & F2FS_COMPR_FL) && (iflags & F2FS_NOCOMP_FL))
1979 return -EINVAL;
1980 }
1981
1982 if ((iflags ^ masked_flags) & F2FS_COMPR_FL) {
1983 if (masked_flags & F2FS_COMPR_FL) {
1984 if (!f2fs_disable_compressed_file(inode))
1985 return -EINVAL;
1986 } else {
1987 /* try to convert inline_data to support compression */
1988 int err = f2fs_convert_inline_inode(inode);
1989 if (err)
1990 return err;
1991
1992 f2fs_down_write(&fi->i_sem);
1993 if (!f2fs_may_compress(inode) ||
1994 (S_ISREG(inode->i_mode) &&
1995 F2FS_HAS_BLOCKS(inode))) {
1996 f2fs_up_write(&fi->i_sem);
1997 return -EINVAL;
1998 }
1999 err = set_compress_context(inode);
2000 f2fs_up_write(&fi->i_sem);
2001
2002 if (err)
2003 return err;
2004 }
2005 }
2006
2007 fi->i_flags = iflags | (fi->i_flags & ~mask);
2008 f2fs_bug_on(F2FS_I_SB(inode), (fi->i_flags & F2FS_COMPR_FL) &&
2009 (fi->i_flags & F2FS_NOCOMP_FL));
2010
2011 if (fi->i_flags & F2FS_PROJINHERIT_FL)
2012 set_inode_flag(inode, FI_PROJ_INHERIT);
2013 else
2014 clear_inode_flag(inode, FI_PROJ_INHERIT);
2015
2016 inode_set_ctime_current(inode);
2017 f2fs_set_inode_flags(inode);
2018 f2fs_mark_inode_dirty_sync(inode, true);
2019 return 0;
2020 }
2021
2022 /* FS_IOC_[GS]ETFLAGS and FS_IOC_FS[GS]ETXATTR support */
2023
2024 /*
2025 * To make a new on-disk f2fs i_flag gettable via FS_IOC_GETFLAGS, add an entry
2026 * for it to f2fs_fsflags_map[], and add its FS_*_FL equivalent to
2027 * F2FS_GETTABLE_FS_FL. To also make it settable via FS_IOC_SETFLAGS, also add
2028 * its FS_*_FL equivalent to F2FS_SETTABLE_FS_FL.
2029 *
2030 * Translating flags to fsx_flags value used by FS_IOC_FSGETXATTR and
2031 * FS_IOC_FSSETXATTR is done by the VFS.
2032 */
2033
2034 static const struct {
2035 u32 iflag;
2036 u32 fsflag;
2037 } f2fs_fsflags_map[] = {
2038 { F2FS_COMPR_FL, FS_COMPR_FL },
2039 { F2FS_SYNC_FL, FS_SYNC_FL },
2040 { F2FS_IMMUTABLE_FL, FS_IMMUTABLE_FL },
2041 { F2FS_APPEND_FL, FS_APPEND_FL },
2042 { F2FS_NODUMP_FL, FS_NODUMP_FL },
2043 { F2FS_NOATIME_FL, FS_NOATIME_FL },
2044 { F2FS_NOCOMP_FL, FS_NOCOMP_FL },
2045 { F2FS_INDEX_FL, FS_INDEX_FL },
2046 { F2FS_DIRSYNC_FL, FS_DIRSYNC_FL },
2047 { F2FS_PROJINHERIT_FL, FS_PROJINHERIT_FL },
2048 { F2FS_CASEFOLD_FL, FS_CASEFOLD_FL },
2049 };
2050
2051 #define F2FS_GETTABLE_FS_FL ( \
2052 FS_COMPR_FL | \
2053 FS_SYNC_FL | \
2054 FS_IMMUTABLE_FL | \
2055 FS_APPEND_FL | \
2056 FS_NODUMP_FL | \
2057 FS_NOATIME_FL | \
2058 FS_NOCOMP_FL | \
2059 FS_INDEX_FL | \
2060 FS_DIRSYNC_FL | \
2061 FS_PROJINHERIT_FL | \
2062 FS_ENCRYPT_FL | \
2063 FS_INLINE_DATA_FL | \
2064 FS_NOCOW_FL | \
2065 FS_VERITY_FL | \
2066 FS_CASEFOLD_FL)
2067
2068 #define F2FS_SETTABLE_FS_FL ( \
2069 FS_COMPR_FL | \
2070 FS_SYNC_FL | \
2071 FS_IMMUTABLE_FL | \
2072 FS_APPEND_FL | \
2073 FS_NODUMP_FL | \
2074 FS_NOATIME_FL | \
2075 FS_NOCOMP_FL | \
2076 FS_DIRSYNC_FL | \
2077 FS_PROJINHERIT_FL | \
2078 FS_CASEFOLD_FL)
2079
2080 /* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
f2fs_iflags_to_fsflags(u32 iflags)2081 static inline u32 f2fs_iflags_to_fsflags(u32 iflags)
2082 {
2083 u32 fsflags = 0;
2084 int i;
2085
2086 for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
2087 if (iflags & f2fs_fsflags_map[i].iflag)
2088 fsflags |= f2fs_fsflags_map[i].fsflag;
2089
2090 return fsflags;
2091 }
2092
2093 /* Convert FS_IOC_{GET,SET}FLAGS flags to f2fs on-disk i_flags */
f2fs_fsflags_to_iflags(u32 fsflags)2094 static inline u32 f2fs_fsflags_to_iflags(u32 fsflags)
2095 {
2096 u32 iflags = 0;
2097 int i;
2098
2099 for (i = 0; i < ARRAY_SIZE(f2fs_fsflags_map); i++)
2100 if (fsflags & f2fs_fsflags_map[i].fsflag)
2101 iflags |= f2fs_fsflags_map[i].iflag;
2102
2103 return iflags;
2104 }
2105
f2fs_ioc_getversion(struct file * filp,unsigned long arg)2106 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
2107 {
2108 struct inode *inode = file_inode(filp);
2109
2110 return put_user(inode->i_generation, (int __user *)arg);
2111 }
2112
f2fs_ioc_start_atomic_write(struct file * filp,bool truncate)2113 static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
2114 {
2115 struct inode *inode = file_inode(filp);
2116 struct mnt_idmap *idmap = file_mnt_idmap(filp);
2117 struct f2fs_inode_info *fi = F2FS_I(inode);
2118 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2119 struct inode *pinode;
2120 loff_t isize;
2121 int ret;
2122
2123 if (!inode_owner_or_capable(idmap, inode))
2124 return -EACCES;
2125
2126 if (!S_ISREG(inode->i_mode))
2127 return -EINVAL;
2128
2129 if (filp->f_flags & O_DIRECT)
2130 return -EINVAL;
2131
2132 ret = mnt_want_write_file(filp);
2133 if (ret)
2134 return ret;
2135
2136 inode_lock(inode);
2137
2138 if (!f2fs_disable_compressed_file(inode) ||
2139 f2fs_is_pinned_file(inode)) {
2140 ret = -EINVAL;
2141 goto out;
2142 }
2143
2144 if (f2fs_is_atomic_file(inode))
2145 goto out;
2146
2147 ret = f2fs_convert_inline_inode(inode);
2148 if (ret)
2149 goto out;
2150
2151 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
2152
2153 /*
2154 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
2155 * f2fs_is_atomic_file.
2156 */
2157 if (get_dirty_pages(inode))
2158 f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2159 inode->i_ino, get_dirty_pages(inode));
2160 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
2161 if (ret) {
2162 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2163 goto out;
2164 }
2165
2166 /* Check if the inode already has a COW inode */
2167 if (fi->cow_inode == NULL) {
2168 /* Create a COW inode for atomic write */
2169 pinode = f2fs_iget(inode->i_sb, fi->i_pino);
2170 if (IS_ERR(pinode)) {
2171 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2172 ret = PTR_ERR(pinode);
2173 goto out;
2174 }
2175
2176 ret = f2fs_get_tmpfile(idmap, pinode, &fi->cow_inode);
2177 iput(pinode);
2178 if (ret) {
2179 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2180 goto out;
2181 }
2182
2183 set_inode_flag(fi->cow_inode, FI_COW_FILE);
2184 clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
2185
2186 /* Set the COW inode's atomic_inode to the atomic inode */
2187 F2FS_I(fi->cow_inode)->atomic_inode = inode;
2188 } else {
2189 /* Reuse the already created COW inode */
2190 ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
2191 if (ret) {
2192 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2193 goto out;
2194 }
2195 }
2196
2197 f2fs_write_inode(inode, NULL);
2198
2199 stat_inc_atomic_inode(inode);
2200
2201 set_inode_flag(inode, FI_ATOMIC_FILE);
2202
2203 isize = i_size_read(inode);
2204 fi->original_i_size = isize;
2205 if (truncate) {
2206 set_inode_flag(inode, FI_ATOMIC_REPLACE);
2207 truncate_inode_pages_final(inode->i_mapping);
2208 f2fs_i_size_write(inode, 0);
2209 isize = 0;
2210 }
2211 f2fs_i_size_write(fi->cow_inode, isize);
2212
2213 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
2214
2215 f2fs_update_time(sbi, REQ_TIME);
2216 fi->atomic_write_task = current;
2217 stat_update_max_atomic_write(inode);
2218 fi->atomic_write_cnt = 0;
2219 out:
2220 inode_unlock(inode);
2221 mnt_drop_write_file(filp);
2222 return ret;
2223 }
2224
f2fs_ioc_commit_atomic_write(struct file * filp)2225 static int f2fs_ioc_commit_atomic_write(struct file *filp)
2226 {
2227 struct inode *inode = file_inode(filp);
2228 struct mnt_idmap *idmap = file_mnt_idmap(filp);
2229 int ret;
2230
2231 if (!inode_owner_or_capable(idmap, inode))
2232 return -EACCES;
2233
2234 ret = mnt_want_write_file(filp);
2235 if (ret)
2236 return ret;
2237
2238 f2fs_balance_fs(F2FS_I_SB(inode), true);
2239
2240 inode_lock(inode);
2241
2242 if (f2fs_is_atomic_file(inode)) {
2243 ret = f2fs_commit_atomic_write(inode);
2244 if (!ret)
2245 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
2246
2247 f2fs_abort_atomic_write(inode, ret);
2248 } else {
2249 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
2250 }
2251
2252 inode_unlock(inode);
2253 mnt_drop_write_file(filp);
2254 return ret;
2255 }
2256
f2fs_ioc_abort_atomic_write(struct file * filp)2257 static int f2fs_ioc_abort_atomic_write(struct file *filp)
2258 {
2259 struct inode *inode = file_inode(filp);
2260 struct mnt_idmap *idmap = file_mnt_idmap(filp);
2261 int ret;
2262
2263 if (!inode_owner_or_capable(idmap, inode))
2264 return -EACCES;
2265
2266 ret = mnt_want_write_file(filp);
2267 if (ret)
2268 return ret;
2269
2270 inode_lock(inode);
2271
2272 f2fs_abort_atomic_write(inode, true);
2273
2274 inode_unlock(inode);
2275
2276 mnt_drop_write_file(filp);
2277 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2278 return ret;
2279 }
2280
f2fs_do_shutdown(struct f2fs_sb_info * sbi,unsigned int flag,bool readonly)2281 int f2fs_do_shutdown(struct f2fs_sb_info *sbi, unsigned int flag,
2282 bool readonly)
2283 {
2284 struct super_block *sb = sbi->sb;
2285 int ret = 0;
2286
2287 switch (flag) {
2288 case F2FS_GOING_DOWN_FULLSYNC:
2289 ret = bdev_freeze(sb->s_bdev);
2290 if (ret)
2291 goto out;
2292 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2293 bdev_thaw(sb->s_bdev);
2294 break;
2295 case F2FS_GOING_DOWN_METASYNC:
2296 /* do checkpoint only */
2297 ret = f2fs_sync_fs(sb, 1);
2298 if (ret) {
2299 if (ret == -EIO)
2300 ret = 0;
2301 goto out;
2302 }
2303 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2304 break;
2305 case F2FS_GOING_DOWN_NOSYNC:
2306 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2307 break;
2308 case F2FS_GOING_DOWN_METAFLUSH:
2309 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
2310 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
2311 break;
2312 case F2FS_GOING_DOWN_NEED_FSCK:
2313 set_sbi_flag(sbi, SBI_NEED_FSCK);
2314 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
2315 set_sbi_flag(sbi, SBI_IS_DIRTY);
2316 /* do checkpoint only */
2317 ret = f2fs_sync_fs(sb, 1);
2318 if (ret == -EIO)
2319 ret = 0;
2320 goto out;
2321 default:
2322 ret = -EINVAL;
2323 goto out;
2324 }
2325
2326 if (readonly)
2327 goto out;
2328
2329 f2fs_stop_gc_thread(sbi);
2330 f2fs_stop_discard_thread(sbi);
2331
2332 f2fs_drop_discard_cmd(sbi);
2333 clear_opt(sbi, DISCARD);
2334
2335 f2fs_update_time(sbi, REQ_TIME);
2336 out:
2337
2338 trace_f2fs_shutdown(sbi, flag, ret);
2339
2340 return ret;
2341 }
2342
f2fs_ioc_shutdown(struct file * filp,unsigned long arg)2343 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
2344 {
2345 struct inode *inode = file_inode(filp);
2346 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2347 __u32 in;
2348 int ret;
2349 bool need_drop = false, readonly = false;
2350
2351 if (!capable(CAP_SYS_ADMIN))
2352 return -EPERM;
2353
2354 if (get_user(in, (__u32 __user *)arg))
2355 return -EFAULT;
2356
2357 if (in != F2FS_GOING_DOWN_FULLSYNC) {
2358 ret = mnt_want_write_file(filp);
2359 if (ret) {
2360 if (ret != -EROFS)
2361 return ret;
2362
2363 /* fallback to nosync shutdown for readonly fs */
2364 in = F2FS_GOING_DOWN_NOSYNC;
2365 readonly = true;
2366 } else {
2367 need_drop = true;
2368 }
2369 }
2370
2371 ret = f2fs_do_shutdown(sbi, in, readonly);
2372
2373 if (need_drop)
2374 mnt_drop_write_file(filp);
2375
2376 return ret;
2377 }
2378
f2fs_ioc_fitrim(struct file * filp,unsigned long arg)2379 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
2380 {
2381 struct inode *inode = file_inode(filp);
2382 struct super_block *sb = inode->i_sb;
2383 struct fstrim_range range;
2384 int ret;
2385
2386 if (!capable(CAP_SYS_ADMIN))
2387 return -EPERM;
2388
2389 if (!f2fs_hw_support_discard(F2FS_SB(sb)))
2390 return -EOPNOTSUPP;
2391
2392 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
2393 sizeof(range)))
2394 return -EFAULT;
2395
2396 ret = mnt_want_write_file(filp);
2397 if (ret)
2398 return ret;
2399
2400 range.minlen = max((unsigned int)range.minlen,
2401 bdev_discard_granularity(sb->s_bdev));
2402 ret = f2fs_trim_fs(F2FS_SB(sb), &range);
2403 mnt_drop_write_file(filp);
2404 if (ret < 0)
2405 return ret;
2406
2407 if (copy_to_user((struct fstrim_range __user *)arg, &range,
2408 sizeof(range)))
2409 return -EFAULT;
2410 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2411 return 0;
2412 }
2413
uuid_is_nonzero(__u8 u[16])2414 static bool uuid_is_nonzero(__u8 u[16])
2415 {
2416 int i;
2417
2418 for (i = 0; i < 16; i++)
2419 if (u[i])
2420 return true;
2421 return false;
2422 }
2423
f2fs_ioc_set_encryption_policy(struct file * filp,unsigned long arg)2424 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
2425 {
2426 struct inode *inode = file_inode(filp);
2427 int ret;
2428
2429 if (!f2fs_sb_has_encrypt(F2FS_I_SB(inode)))
2430 return -EOPNOTSUPP;
2431
2432 ret = fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
2433 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2434 return ret;
2435 }
2436
f2fs_ioc_get_encryption_policy(struct file * filp,unsigned long arg)2437 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
2438 {
2439 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2440 return -EOPNOTSUPP;
2441 return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
2442 }
2443
f2fs_ioc_get_encryption_pwsalt(struct file * filp,unsigned long arg)2444 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
2445 {
2446 struct inode *inode = file_inode(filp);
2447 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2448 u8 encrypt_pw_salt[16];
2449 int err;
2450
2451 if (!f2fs_sb_has_encrypt(sbi))
2452 return -EOPNOTSUPP;
2453
2454 err = mnt_want_write_file(filp);
2455 if (err)
2456 return err;
2457
2458 f2fs_down_write(&sbi->sb_lock);
2459
2460 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2461 goto got_it;
2462
2463 /* update superblock with uuid */
2464 generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2465
2466 err = f2fs_commit_super(sbi, false);
2467 if (err) {
2468 /* undo new data */
2469 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
2470 goto out_err;
2471 }
2472 got_it:
2473 memcpy(encrypt_pw_salt, sbi->raw_super->encrypt_pw_salt, 16);
2474 out_err:
2475 f2fs_up_write(&sbi->sb_lock);
2476 mnt_drop_write_file(filp);
2477
2478 if (!err && copy_to_user((__u8 __user *)arg, encrypt_pw_salt, 16))
2479 err = -EFAULT;
2480
2481 return err;
2482 }
2483
f2fs_ioc_get_encryption_policy_ex(struct file * filp,unsigned long arg)2484 static int f2fs_ioc_get_encryption_policy_ex(struct file *filp,
2485 unsigned long arg)
2486 {
2487 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2488 return -EOPNOTSUPP;
2489
2490 return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
2491 }
2492
f2fs_ioc_add_encryption_key(struct file * filp,unsigned long arg)2493 static int f2fs_ioc_add_encryption_key(struct file *filp, unsigned long arg)
2494 {
2495 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2496 return -EOPNOTSUPP;
2497
2498 return fscrypt_ioctl_add_key(filp, (void __user *)arg);
2499 }
2500
f2fs_ioc_remove_encryption_key(struct file * filp,unsigned long arg)2501 static int f2fs_ioc_remove_encryption_key(struct file *filp, unsigned long arg)
2502 {
2503 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2504 return -EOPNOTSUPP;
2505
2506 return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
2507 }
2508
f2fs_ioc_remove_encryption_key_all_users(struct file * filp,unsigned long arg)2509 static int f2fs_ioc_remove_encryption_key_all_users(struct file *filp,
2510 unsigned long arg)
2511 {
2512 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2513 return -EOPNOTSUPP;
2514
2515 return fscrypt_ioctl_remove_key_all_users(filp, (void __user *)arg);
2516 }
2517
f2fs_ioc_get_encryption_key_status(struct file * filp,unsigned long arg)2518 static int f2fs_ioc_get_encryption_key_status(struct file *filp,
2519 unsigned long arg)
2520 {
2521 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2522 return -EOPNOTSUPP;
2523
2524 return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
2525 }
2526
f2fs_ioc_get_encryption_nonce(struct file * filp,unsigned long arg)2527 static int f2fs_ioc_get_encryption_nonce(struct file *filp, unsigned long arg)
2528 {
2529 if (!f2fs_sb_has_encrypt(F2FS_I_SB(file_inode(filp))))
2530 return -EOPNOTSUPP;
2531
2532 return fscrypt_ioctl_get_nonce(filp, (void __user *)arg);
2533 }
2534
f2fs_ioc_gc(struct file * filp,unsigned long arg)2535 static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
2536 {
2537 struct inode *inode = file_inode(filp);
2538 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2539 struct f2fs_gc_control gc_control = { .victim_segno = NULL_SEGNO,
2540 .no_bg_gc = false,
2541 .should_migrate_blocks = false,
2542 .nr_free_secs = 0 };
2543 __u32 sync;
2544 int ret;
2545
2546 if (!capable(CAP_SYS_ADMIN))
2547 return -EPERM;
2548
2549 if (get_user(sync, (__u32 __user *)arg))
2550 return -EFAULT;
2551
2552 if (f2fs_readonly(sbi->sb))
2553 return -EROFS;
2554
2555 ret = mnt_want_write_file(filp);
2556 if (ret)
2557 return ret;
2558
2559 if (!sync) {
2560 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2561 ret = -EBUSY;
2562 goto out;
2563 }
2564 } else {
2565 f2fs_down_write(&sbi->gc_lock);
2566 }
2567
2568 gc_control.init_gc_type = sync ? FG_GC : BG_GC;
2569 gc_control.err_gc_skipped = sync;
2570 stat_inc_gc_call_count(sbi, FOREGROUND);
2571 ret = f2fs_gc(sbi, &gc_control);
2572 out:
2573 mnt_drop_write_file(filp);
2574 return ret;
2575 }
2576
__f2fs_ioc_gc_range(struct file * filp,struct f2fs_gc_range * range)2577 static int __f2fs_ioc_gc_range(struct file *filp, struct f2fs_gc_range *range)
2578 {
2579 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
2580 struct f2fs_gc_control gc_control = {
2581 .init_gc_type = range->sync ? FG_GC : BG_GC,
2582 .no_bg_gc = false,
2583 .should_migrate_blocks = false,
2584 .err_gc_skipped = range->sync,
2585 .nr_free_secs = 0 };
2586 u64 end;
2587 int ret;
2588
2589 if (!capable(CAP_SYS_ADMIN))
2590 return -EPERM;
2591 if (f2fs_readonly(sbi->sb))
2592 return -EROFS;
2593
2594 end = range->start + range->len;
2595 if (end < range->start || range->start < MAIN_BLKADDR(sbi) ||
2596 end >= MAX_BLKADDR(sbi))
2597 return -EINVAL;
2598
2599 ret = mnt_want_write_file(filp);
2600 if (ret)
2601 return ret;
2602
2603 do_more:
2604 if (!range->sync) {
2605 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
2606 ret = -EBUSY;
2607 goto out;
2608 }
2609 } else {
2610 f2fs_down_write(&sbi->gc_lock);
2611 }
2612
2613 gc_control.victim_segno = GET_SEGNO(sbi, range->start);
2614 stat_inc_gc_call_count(sbi, FOREGROUND);
2615 ret = f2fs_gc(sbi, &gc_control);
2616 if (ret) {
2617 if (ret == -EBUSY)
2618 ret = -EAGAIN;
2619 goto out;
2620 }
2621 range->start += CAP_BLKS_PER_SEC(sbi);
2622 if (range->start <= end)
2623 goto do_more;
2624 out:
2625 mnt_drop_write_file(filp);
2626 return ret;
2627 }
2628
f2fs_ioc_gc_range(struct file * filp,unsigned long arg)2629 static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg)
2630 {
2631 struct f2fs_gc_range range;
2632
2633 if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg,
2634 sizeof(range)))
2635 return -EFAULT;
2636 return __f2fs_ioc_gc_range(filp, &range);
2637 }
2638
f2fs_ioc_write_checkpoint(struct file * filp)2639 static int f2fs_ioc_write_checkpoint(struct file *filp)
2640 {
2641 struct inode *inode = file_inode(filp);
2642 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2643 int ret;
2644
2645 if (!capable(CAP_SYS_ADMIN))
2646 return -EPERM;
2647
2648 if (f2fs_readonly(sbi->sb))
2649 return -EROFS;
2650
2651 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2652 f2fs_info(sbi, "Skipping Checkpoint. Checkpoints currently disabled.");
2653 return -EINVAL;
2654 }
2655
2656 ret = mnt_want_write_file(filp);
2657 if (ret)
2658 return ret;
2659
2660 ret = f2fs_sync_fs(sbi->sb, 1);
2661
2662 mnt_drop_write_file(filp);
2663 return ret;
2664 }
2665
f2fs_defragment_range(struct f2fs_sb_info * sbi,struct file * filp,struct f2fs_defragment * range)2666 static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
2667 struct file *filp,
2668 struct f2fs_defragment *range)
2669 {
2670 struct inode *inode = file_inode(filp);
2671 struct f2fs_map_blocks map = { .m_next_extent = NULL,
2672 .m_seg_type = NO_CHECK_TYPE,
2673 .m_may_create = false };
2674 struct extent_info ei = {};
2675 pgoff_t pg_start, pg_end, next_pgofs;
2676 unsigned int total = 0, sec_num;
2677 block_t blk_end = 0;
2678 bool fragmented = false;
2679 int err;
2680
2681 f2fs_balance_fs(sbi, true);
2682
2683 inode_lock(inode);
2684 pg_start = range->start >> PAGE_SHIFT;
2685 pg_end = min_t(pgoff_t,
2686 (range->start + range->len) >> PAGE_SHIFT,
2687 DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE));
2688
2689 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
2690 err = -EINVAL;
2691 goto unlock_out;
2692 }
2693
2694 /* if in-place-update policy is enabled, don't waste time here */
2695 set_inode_flag(inode, FI_OPU_WRITE);
2696 if (f2fs_should_update_inplace(inode, NULL)) {
2697 err = -EINVAL;
2698 goto out;
2699 }
2700
2701 /* writeback all dirty pages in the range */
2702 err = filemap_write_and_wait_range(inode->i_mapping,
2703 pg_start << PAGE_SHIFT,
2704 (pg_end << PAGE_SHIFT) - 1);
2705 if (err)
2706 goto out;
2707
2708 /*
2709 * lookup mapping info in extent cache, skip defragmenting if physical
2710 * block addresses are continuous.
2711 */
2712 if (f2fs_lookup_read_extent_cache(inode, pg_start, &ei)) {
2713 if (ei.fofs + ei.len >= pg_end)
2714 goto out;
2715 }
2716
2717 map.m_lblk = pg_start;
2718 map.m_next_pgofs = &next_pgofs;
2719
2720 /*
2721 * lookup mapping info in dnode page cache, skip defragmenting if all
2722 * physical block addresses are continuous even if there are hole(s)
2723 * in logical blocks.
2724 */
2725 while (map.m_lblk < pg_end) {
2726 map.m_len = pg_end - map.m_lblk;
2727 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
2728 if (err)
2729 goto out;
2730
2731 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2732 map.m_lblk = next_pgofs;
2733 continue;
2734 }
2735
2736 if (blk_end && blk_end != map.m_pblk)
2737 fragmented = true;
2738
2739 /* record total count of block that we're going to move */
2740 total += map.m_len;
2741
2742 blk_end = map.m_pblk + map.m_len;
2743
2744 map.m_lblk += map.m_len;
2745 }
2746
2747 if (!fragmented) {
2748 total = 0;
2749 goto out;
2750 }
2751
2752 sec_num = DIV_ROUND_UP(total, CAP_BLKS_PER_SEC(sbi));
2753
2754 /*
2755 * make sure there are enough free section for LFS allocation, this can
2756 * avoid defragment running in SSR mode when free section are allocated
2757 * intensively
2758 */
2759 if (has_not_enough_free_secs(sbi, 0, sec_num)) {
2760 err = -EAGAIN;
2761 goto out;
2762 }
2763
2764 map.m_lblk = pg_start;
2765 map.m_len = pg_end - pg_start;
2766 total = 0;
2767
2768 while (map.m_lblk < pg_end) {
2769 pgoff_t idx;
2770 int cnt = 0;
2771
2772 do_map:
2773 map.m_len = pg_end - map.m_lblk;
2774 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_DEFAULT);
2775 if (err)
2776 goto clear_out;
2777
2778 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2779 map.m_lblk = next_pgofs;
2780 goto check;
2781 }
2782
2783 set_inode_flag(inode, FI_SKIP_WRITES);
2784
2785 idx = map.m_lblk;
2786 while (idx < map.m_lblk + map.m_len &&
2787 cnt < BLKS_PER_SEG(sbi)) {
2788 struct page *page;
2789
2790 page = f2fs_get_lock_data_page(inode, idx, true);
2791 if (IS_ERR(page)) {
2792 err = PTR_ERR(page);
2793 goto clear_out;
2794 }
2795
2796 set_page_dirty(page);
2797 set_page_private_gcing(page);
2798 f2fs_put_page(page, 1);
2799
2800 idx++;
2801 cnt++;
2802 total++;
2803 }
2804
2805 map.m_lblk = idx;
2806 check:
2807 if (map.m_lblk < pg_end && cnt < BLKS_PER_SEG(sbi))
2808 goto do_map;
2809
2810 clear_inode_flag(inode, FI_SKIP_WRITES);
2811
2812 err = filemap_fdatawrite(inode->i_mapping);
2813 if (err)
2814 goto out;
2815 }
2816 clear_out:
2817 clear_inode_flag(inode, FI_SKIP_WRITES);
2818 out:
2819 clear_inode_flag(inode, FI_OPU_WRITE);
2820 unlock_out:
2821 inode_unlock(inode);
2822 if (!err)
2823 range->len = (u64)total << PAGE_SHIFT;
2824 return err;
2825 }
2826
f2fs_ioc_defragment(struct file * filp,unsigned long arg)2827 static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
2828 {
2829 struct inode *inode = file_inode(filp);
2830 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2831 struct f2fs_defragment range;
2832 int err;
2833
2834 if (!capable(CAP_SYS_ADMIN))
2835 return -EPERM;
2836
2837 if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
2838 return -EINVAL;
2839
2840 if (f2fs_readonly(sbi->sb))
2841 return -EROFS;
2842
2843 if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
2844 sizeof(range)))
2845 return -EFAULT;
2846
2847 /* verify alignment of offset & size */
2848 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2849 return -EINVAL;
2850
2851 if (unlikely((range.start + range.len) >> PAGE_SHIFT >
2852 max_file_blocks(inode)))
2853 return -EINVAL;
2854
2855 err = mnt_want_write_file(filp);
2856 if (err)
2857 return err;
2858
2859 err = f2fs_defragment_range(sbi, filp, &range);
2860 mnt_drop_write_file(filp);
2861
2862 if (range.len)
2863 f2fs_update_time(sbi, REQ_TIME);
2864 if (err < 0)
2865 return err;
2866
2867 if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
2868 sizeof(range)))
2869 return -EFAULT;
2870
2871 return 0;
2872 }
2873
f2fs_move_file_range(struct file * file_in,loff_t pos_in,struct file * file_out,loff_t pos_out,size_t len)2874 static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2875 struct file *file_out, loff_t pos_out, size_t len)
2876 {
2877 struct inode *src = file_inode(file_in);
2878 struct inode *dst = file_inode(file_out);
2879 struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2880 size_t olen = len, dst_max_i_size = 0;
2881 size_t dst_osize;
2882 int ret;
2883
2884 if (file_in->f_path.mnt != file_out->f_path.mnt ||
2885 src->i_sb != dst->i_sb)
2886 return -EXDEV;
2887
2888 if (unlikely(f2fs_readonly(src->i_sb)))
2889 return -EROFS;
2890
2891 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
2892 return -EINVAL;
2893
2894 if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst))
2895 return -EOPNOTSUPP;
2896
2897 if (pos_out < 0 || pos_in < 0)
2898 return -EINVAL;
2899
2900 if (src == dst) {
2901 if (pos_in == pos_out)
2902 return 0;
2903 if (pos_out > pos_in && pos_out < pos_in + len)
2904 return -EINVAL;
2905 }
2906
2907 inode_lock(src);
2908 if (src != dst) {
2909 ret = -EBUSY;
2910 if (!inode_trylock(dst))
2911 goto out;
2912 }
2913
2914 if (f2fs_compressed_file(src) || f2fs_compressed_file(dst) ||
2915 f2fs_is_pinned_file(src) || f2fs_is_pinned_file(dst)) {
2916 ret = -EOPNOTSUPP;
2917 goto out_unlock;
2918 }
2919
2920 ret = -EINVAL;
2921 if (pos_in + len > src->i_size || pos_in + len < pos_in)
2922 goto out_unlock;
2923 if (len == 0)
2924 olen = len = src->i_size - pos_in;
2925 if (pos_in + len == src->i_size)
2926 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2927 if (len == 0) {
2928 ret = 0;
2929 goto out_unlock;
2930 }
2931
2932 dst_osize = dst->i_size;
2933 if (pos_out + olen > dst->i_size)
2934 dst_max_i_size = pos_out + olen;
2935
2936 /* verify the end result is block aligned */
2937 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2938 !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2939 !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2940 goto out_unlock;
2941
2942 ret = f2fs_convert_inline_inode(src);
2943 if (ret)
2944 goto out_unlock;
2945
2946 ret = f2fs_convert_inline_inode(dst);
2947 if (ret)
2948 goto out_unlock;
2949
2950 /* write out all dirty pages from offset */
2951 ret = filemap_write_and_wait_range(src->i_mapping,
2952 pos_in, pos_in + len);
2953 if (ret)
2954 goto out_unlock;
2955
2956 ret = filemap_write_and_wait_range(dst->i_mapping,
2957 pos_out, pos_out + len);
2958 if (ret)
2959 goto out_unlock;
2960
2961 f2fs_balance_fs(sbi, true);
2962
2963 f2fs_down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2964 if (src != dst) {
2965 ret = -EBUSY;
2966 if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
2967 goto out_src;
2968 }
2969
2970 f2fs_lock_op(sbi);
2971 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2972 pos_out >> F2FS_BLKSIZE_BITS,
2973 len >> F2FS_BLKSIZE_BITS, false);
2974
2975 if (!ret) {
2976 if (dst_max_i_size)
2977 f2fs_i_size_write(dst, dst_max_i_size);
2978 else if (dst_osize != dst->i_size)
2979 f2fs_i_size_write(dst, dst_osize);
2980 }
2981 f2fs_unlock_op(sbi);
2982
2983 if (src != dst)
2984 f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
2985 out_src:
2986 f2fs_up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
2987 if (ret)
2988 goto out_unlock;
2989
2990 inode_set_mtime_to_ts(src, inode_set_ctime_current(src));
2991 f2fs_mark_inode_dirty_sync(src, false);
2992 if (src != dst) {
2993 inode_set_mtime_to_ts(dst, inode_set_ctime_current(dst));
2994 f2fs_mark_inode_dirty_sync(dst, false);
2995 }
2996 f2fs_update_time(sbi, REQ_TIME);
2997
2998 out_unlock:
2999 if (src != dst)
3000 inode_unlock(dst);
3001 out:
3002 inode_unlock(src);
3003 return ret;
3004 }
3005
__f2fs_ioc_move_range(struct file * filp,struct f2fs_move_range * range)3006 static int __f2fs_ioc_move_range(struct file *filp,
3007 struct f2fs_move_range *range)
3008 {
3009 struct fd dst;
3010 int err;
3011
3012 if (!(filp->f_mode & FMODE_READ) ||
3013 !(filp->f_mode & FMODE_WRITE))
3014 return -EBADF;
3015
3016 dst = fdget(range->dst_fd);
3017 if (!dst.file)
3018 return -EBADF;
3019
3020 if (!(dst.file->f_mode & FMODE_WRITE)) {
3021 err = -EBADF;
3022 goto err_out;
3023 }
3024
3025 err = mnt_want_write_file(filp);
3026 if (err)
3027 goto err_out;
3028
3029 err = f2fs_move_file_range(filp, range->pos_in, dst.file,
3030 range->pos_out, range->len);
3031
3032 mnt_drop_write_file(filp);
3033 err_out:
3034 fdput(dst);
3035 return err;
3036 }
3037
f2fs_ioc_move_range(struct file * filp,unsigned long arg)3038 static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
3039 {
3040 struct f2fs_move_range range;
3041
3042 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
3043 sizeof(range)))
3044 return -EFAULT;
3045 return __f2fs_ioc_move_range(filp, &range);
3046 }
3047
f2fs_ioc_flush_device(struct file * filp,unsigned long arg)3048 static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
3049 {
3050 struct inode *inode = file_inode(filp);
3051 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3052 struct sit_info *sm = SIT_I(sbi);
3053 unsigned int start_segno = 0, end_segno = 0;
3054 unsigned int dev_start_segno = 0, dev_end_segno = 0;
3055 struct f2fs_flush_device range;
3056 struct f2fs_gc_control gc_control = {
3057 .init_gc_type = FG_GC,
3058 .should_migrate_blocks = true,
3059 .err_gc_skipped = true,
3060 .nr_free_secs = 0 };
3061 int ret;
3062
3063 if (!capable(CAP_SYS_ADMIN))
3064 return -EPERM;
3065
3066 if (f2fs_readonly(sbi->sb))
3067 return -EROFS;
3068
3069 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
3070 return -EINVAL;
3071
3072 if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
3073 sizeof(range)))
3074 return -EFAULT;
3075
3076 if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num ||
3077 __is_large_section(sbi)) {
3078 f2fs_warn(sbi, "Can't flush %u in %d for SEGS_PER_SEC %u != 1",
3079 range.dev_num, sbi->s_ndevs, SEGS_PER_SEC(sbi));
3080 return -EINVAL;
3081 }
3082
3083 ret = mnt_want_write_file(filp);
3084 if (ret)
3085 return ret;
3086
3087 if (range.dev_num != 0)
3088 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
3089 dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
3090
3091 start_segno = sm->last_victim[FLUSH_DEVICE];
3092 if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
3093 start_segno = dev_start_segno;
3094 end_segno = min(start_segno + range.segments, dev_end_segno);
3095
3096 while (start_segno < end_segno) {
3097 if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
3098 ret = -EBUSY;
3099 goto out;
3100 }
3101 sm->last_victim[GC_CB] = end_segno + 1;
3102 sm->last_victim[GC_GREEDY] = end_segno + 1;
3103 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
3104
3105 gc_control.victim_segno = start_segno;
3106 stat_inc_gc_call_count(sbi, FOREGROUND);
3107 ret = f2fs_gc(sbi, &gc_control);
3108 if (ret == -EAGAIN)
3109 ret = 0;
3110 else if (ret < 0)
3111 break;
3112 start_segno++;
3113 }
3114 out:
3115 mnt_drop_write_file(filp);
3116 return ret;
3117 }
3118
f2fs_ioc_get_features(struct file * filp,unsigned long arg)3119 static int f2fs_ioc_get_features(struct file *filp, unsigned long arg)
3120 {
3121 struct inode *inode = file_inode(filp);
3122 u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature);
3123
3124 /* Must validate to set it with SQLite behavior in Android. */
3125 sb_feature |= F2FS_FEATURE_ATOMIC_WRITE;
3126
3127 return put_user(sb_feature, (u32 __user *)arg);
3128 }
3129
3130 #ifdef CONFIG_QUOTA
f2fs_transfer_project_quota(struct inode * inode,kprojid_t kprojid)3131 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
3132 {
3133 struct dquot *transfer_to[MAXQUOTAS] = {};
3134 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3135 struct super_block *sb = sbi->sb;
3136 int err;
3137
3138 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
3139 if (IS_ERR(transfer_to[PRJQUOTA]))
3140 return PTR_ERR(transfer_to[PRJQUOTA]);
3141
3142 err = __dquot_transfer(inode, transfer_to);
3143 if (err)
3144 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3145 dqput(transfer_to[PRJQUOTA]);
3146 return err;
3147 }
3148
f2fs_ioc_setproject(struct inode * inode,__u32 projid)3149 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
3150 {
3151 struct f2fs_inode_info *fi = F2FS_I(inode);
3152 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3153 struct f2fs_inode *ri = NULL;
3154 kprojid_t kprojid;
3155 int err;
3156
3157 if (!f2fs_sb_has_project_quota(sbi)) {
3158 if (projid != F2FS_DEF_PROJID)
3159 return -EOPNOTSUPP;
3160 else
3161 return 0;
3162 }
3163
3164 if (!f2fs_has_extra_attr(inode))
3165 return -EOPNOTSUPP;
3166
3167 kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
3168
3169 if (projid_eq(kprojid, fi->i_projid))
3170 return 0;
3171
3172 err = -EPERM;
3173 /* Is it quota file? Do not allow user to mess with it */
3174 if (IS_NOQUOTA(inode))
3175 return err;
3176
3177 if (!F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid))
3178 return -EOVERFLOW;
3179
3180 err = f2fs_dquot_initialize(inode);
3181 if (err)
3182 return err;
3183
3184 f2fs_lock_op(sbi);
3185 err = f2fs_transfer_project_quota(inode, kprojid);
3186 if (err)
3187 goto out_unlock;
3188
3189 fi->i_projid = kprojid;
3190 inode_set_ctime_current(inode);
3191 f2fs_mark_inode_dirty_sync(inode, true);
3192 out_unlock:
3193 f2fs_unlock_op(sbi);
3194 return err;
3195 }
3196 #else
f2fs_transfer_project_quota(struct inode * inode,kprojid_t kprojid)3197 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid)
3198 {
3199 return 0;
3200 }
3201
f2fs_ioc_setproject(struct inode * inode,__u32 projid)3202 static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
3203 {
3204 if (projid != F2FS_DEF_PROJID)
3205 return -EOPNOTSUPP;
3206 return 0;
3207 }
3208 #endif
3209
f2fs_fileattr_get(struct dentry * dentry,struct fileattr * fa)3210 int f2fs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
3211 {
3212 struct inode *inode = d_inode(dentry);
3213 struct f2fs_inode_info *fi = F2FS_I(inode);
3214 u32 fsflags = f2fs_iflags_to_fsflags(fi->i_flags);
3215
3216 if (IS_ENCRYPTED(inode))
3217 fsflags |= FS_ENCRYPT_FL;
3218 if (IS_VERITY(inode))
3219 fsflags |= FS_VERITY_FL;
3220 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode))
3221 fsflags |= FS_INLINE_DATA_FL;
3222 if (is_inode_flag_set(inode, FI_PIN_FILE))
3223 fsflags |= FS_NOCOW_FL;
3224
3225 fileattr_fill_flags(fa, fsflags & F2FS_GETTABLE_FS_FL);
3226
3227 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)))
3228 fa->fsx_projid = from_kprojid(&init_user_ns, fi->i_projid);
3229
3230 return 0;
3231 }
3232
f2fs_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct fileattr * fa)3233 int f2fs_fileattr_set(struct mnt_idmap *idmap,
3234 struct dentry *dentry, struct fileattr *fa)
3235 {
3236 struct inode *inode = d_inode(dentry);
3237 u32 fsflags = fa->flags, mask = F2FS_SETTABLE_FS_FL;
3238 u32 iflags;
3239 int err;
3240
3241 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
3242 return -EIO;
3243 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
3244 return -ENOSPC;
3245 if (fsflags & ~F2FS_GETTABLE_FS_FL)
3246 return -EOPNOTSUPP;
3247 fsflags &= F2FS_SETTABLE_FS_FL;
3248 if (!fa->flags_valid)
3249 mask &= FS_COMMON_FL;
3250
3251 iflags = f2fs_fsflags_to_iflags(fsflags);
3252 if (f2fs_mask_flags(inode->i_mode, iflags) != iflags)
3253 return -EOPNOTSUPP;
3254
3255 err = f2fs_setflags_common(inode, iflags, f2fs_fsflags_to_iflags(mask));
3256 if (!err)
3257 err = f2fs_ioc_setproject(inode, fa->fsx_projid);
3258
3259 return err;
3260 }
3261
f2fs_pin_file_control(struct inode * inode,bool inc)3262 int f2fs_pin_file_control(struct inode *inode, bool inc)
3263 {
3264 struct f2fs_inode_info *fi = F2FS_I(inode);
3265 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3266
3267 if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
3268 f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
3269 __func__, inode->i_ino, fi->i_gc_failures);
3270 clear_inode_flag(inode, FI_PIN_FILE);
3271 return -EAGAIN;
3272 }
3273
3274 /* Use i_gc_failures for normal file as a risk signal. */
3275 if (inc)
3276 f2fs_i_gc_failures_write(inode, fi->i_gc_failures + 1);
3277
3278 return 0;
3279 }
3280
f2fs_ioc_set_pin_file(struct file * filp,unsigned long arg)3281 static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
3282 {
3283 struct inode *inode = file_inode(filp);
3284 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3285 __u32 pin;
3286 int ret = 0;
3287
3288 if (get_user(pin, (__u32 __user *)arg))
3289 return -EFAULT;
3290
3291 if (!S_ISREG(inode->i_mode))
3292 return -EINVAL;
3293
3294 if (f2fs_readonly(sbi->sb))
3295 return -EROFS;
3296
3297 ret = mnt_want_write_file(filp);
3298 if (ret)
3299 return ret;
3300
3301 inode_lock(inode);
3302
3303 if (!pin) {
3304 clear_inode_flag(inode, FI_PIN_FILE);
3305 f2fs_i_gc_failures_write(inode, 0);
3306 goto done;
3307 } else if (f2fs_is_pinned_file(inode)) {
3308 goto done;
3309 }
3310
3311 if (F2FS_HAS_BLOCKS(inode)) {
3312 ret = -EFBIG;
3313 goto out;
3314 }
3315
3316 /* Let's allow file pinning on zoned device. */
3317 if (!f2fs_sb_has_blkzoned(sbi) &&
3318 f2fs_should_update_outplace(inode, NULL)) {
3319 ret = -EINVAL;
3320 goto out;
3321 }
3322
3323 if (f2fs_pin_file_control(inode, false)) {
3324 ret = -EAGAIN;
3325 goto out;
3326 }
3327
3328 ret = f2fs_convert_inline_inode(inode);
3329 if (ret)
3330 goto out;
3331
3332 if (!f2fs_disable_compressed_file(inode)) {
3333 ret = -EOPNOTSUPP;
3334 goto out;
3335 }
3336
3337 set_inode_flag(inode, FI_PIN_FILE);
3338 ret = F2FS_I(inode)->i_gc_failures;
3339 done:
3340 f2fs_update_time(sbi, REQ_TIME);
3341 out:
3342 inode_unlock(inode);
3343 mnt_drop_write_file(filp);
3344 return ret;
3345 }
3346
f2fs_ioc_get_pin_file(struct file * filp,unsigned long arg)3347 static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg)
3348 {
3349 struct inode *inode = file_inode(filp);
3350 __u32 pin = 0;
3351
3352 if (is_inode_flag_set(inode, FI_PIN_FILE))
3353 pin = F2FS_I(inode)->i_gc_failures;
3354 return put_user(pin, (u32 __user *)arg);
3355 }
3356
f2fs_precache_extents(struct inode * inode)3357 int f2fs_precache_extents(struct inode *inode)
3358 {
3359 struct f2fs_inode_info *fi = F2FS_I(inode);
3360 struct f2fs_map_blocks map;
3361 pgoff_t m_next_extent;
3362 loff_t end;
3363 int err;
3364
3365 if (is_inode_flag_set(inode, FI_NO_EXTENT))
3366 return -EOPNOTSUPP;
3367
3368 map.m_lblk = 0;
3369 map.m_pblk = 0;
3370 map.m_next_pgofs = NULL;
3371 map.m_next_extent = &m_next_extent;
3372 map.m_seg_type = NO_CHECK_TYPE;
3373 map.m_may_create = false;
3374 end = F2FS_BLK_ALIGN(i_size_read(inode));
3375
3376 while (map.m_lblk < end) {
3377 map.m_len = end - map.m_lblk;
3378
3379 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
3380 err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRECACHE);
3381 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
3382 if (err || !map.m_len)
3383 return err;
3384
3385 map.m_lblk = m_next_extent;
3386 }
3387
3388 return 0;
3389 }
3390
f2fs_ioc_precache_extents(struct file * filp)3391 static int f2fs_ioc_precache_extents(struct file *filp)
3392 {
3393 return f2fs_precache_extents(file_inode(filp));
3394 }
3395
f2fs_ioc_resize_fs(struct file * filp,unsigned long arg)3396 static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg)
3397 {
3398 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
3399 __u64 block_count;
3400
3401 if (!capable(CAP_SYS_ADMIN))
3402 return -EPERM;
3403
3404 if (f2fs_readonly(sbi->sb))
3405 return -EROFS;
3406
3407 if (copy_from_user(&block_count, (void __user *)arg,
3408 sizeof(block_count)))
3409 return -EFAULT;
3410
3411 return f2fs_resize_fs(filp, block_count);
3412 }
3413
f2fs_ioc_enable_verity(struct file * filp,unsigned long arg)3414 static int f2fs_ioc_enable_verity(struct file *filp, unsigned long arg)
3415 {
3416 struct inode *inode = file_inode(filp);
3417
3418 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
3419
3420 if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {
3421 f2fs_warn(F2FS_I_SB(inode),
3422 "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
3423 inode->i_ino);
3424 return -EOPNOTSUPP;
3425 }
3426
3427 return fsverity_ioctl_enable(filp, (const void __user *)arg);
3428 }
3429
f2fs_ioc_measure_verity(struct file * filp,unsigned long arg)3430 static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)
3431 {
3432 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3433 return -EOPNOTSUPP;
3434
3435 return fsverity_ioctl_measure(filp, (void __user *)arg);
3436 }
3437
f2fs_ioc_read_verity_metadata(struct file * filp,unsigned long arg)3438 static int f2fs_ioc_read_verity_metadata(struct file *filp, unsigned long arg)
3439 {
3440 if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))
3441 return -EOPNOTSUPP;
3442
3443 return fsverity_ioctl_read_metadata(filp, (const void __user *)arg);
3444 }
3445
f2fs_ioc_getfslabel(struct file * filp,unsigned long arg)3446 static int f2fs_ioc_getfslabel(struct file *filp, unsigned long arg)
3447 {
3448 struct inode *inode = file_inode(filp);
3449 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3450 char *vbuf;
3451 int count;
3452 int err = 0;
3453
3454 vbuf = f2fs_kzalloc(sbi, MAX_VOLUME_NAME, GFP_KERNEL);
3455 if (!vbuf)
3456 return -ENOMEM;
3457
3458 f2fs_down_read(&sbi->sb_lock);
3459 count = utf16s_to_utf8s(sbi->raw_super->volume_name,
3460 ARRAY_SIZE(sbi->raw_super->volume_name),
3461 UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
3462 f2fs_up_read(&sbi->sb_lock);
3463
3464 if (copy_to_user((char __user *)arg, vbuf,
3465 min(FSLABEL_MAX, count)))
3466 err = -EFAULT;
3467
3468 kfree(vbuf);
3469 return err;
3470 }
3471
f2fs_ioc_setfslabel(struct file * filp,unsigned long arg)3472 static int f2fs_ioc_setfslabel(struct file *filp, unsigned long arg)
3473 {
3474 struct inode *inode = file_inode(filp);
3475 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3476 char *vbuf;
3477 int err = 0;
3478
3479 if (!capable(CAP_SYS_ADMIN))
3480 return -EPERM;
3481
3482 vbuf = strndup_user((const char __user *)arg, FSLABEL_MAX);
3483 if (IS_ERR(vbuf))
3484 return PTR_ERR(vbuf);
3485
3486 err = mnt_want_write_file(filp);
3487 if (err)
3488 goto out;
3489
3490 f2fs_down_write(&sbi->sb_lock);
3491
3492 memset(sbi->raw_super->volume_name, 0,
3493 sizeof(sbi->raw_super->volume_name));
3494 utf8s_to_utf16s(vbuf, strlen(vbuf), UTF16_LITTLE_ENDIAN,
3495 sbi->raw_super->volume_name,
3496 ARRAY_SIZE(sbi->raw_super->volume_name));
3497
3498 err = f2fs_commit_super(sbi, false);
3499
3500 f2fs_up_write(&sbi->sb_lock);
3501
3502 mnt_drop_write_file(filp);
3503 out:
3504 kfree(vbuf);
3505 return err;
3506 }
3507
f2fs_get_compress_blocks(struct inode * inode,__u64 * blocks)3508 static int f2fs_get_compress_blocks(struct inode *inode, __u64 *blocks)
3509 {
3510 if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
3511 return -EOPNOTSUPP;
3512
3513 if (!f2fs_compressed_file(inode))
3514 return -EINVAL;
3515
3516 *blocks = atomic_read(&F2FS_I(inode)->i_compr_blocks);
3517
3518 return 0;
3519 }
3520
f2fs_ioc_get_compress_blocks(struct file * filp,unsigned long arg)3521 static int f2fs_ioc_get_compress_blocks(struct file *filp, unsigned long arg)
3522 {
3523 struct inode *inode = file_inode(filp);
3524 __u64 blocks;
3525 int ret;
3526
3527 ret = f2fs_get_compress_blocks(inode, &blocks);
3528 if (ret < 0)
3529 return ret;
3530
3531 return put_user(blocks, (u64 __user *)arg);
3532 }
3533
release_compress_blocks(struct dnode_of_data * dn,pgoff_t count)3534 static int release_compress_blocks(struct dnode_of_data *dn, pgoff_t count)
3535 {
3536 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
3537 unsigned int released_blocks = 0;
3538 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
3539 block_t blkaddr;
3540 int i;
3541
3542 for (i = 0; i < count; i++) {
3543 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3544 dn->ofs_in_node + i);
3545
3546 if (!__is_valid_data_blkaddr(blkaddr))
3547 continue;
3548 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr,
3549 DATA_GENERIC_ENHANCE)))
3550 return -EFSCORRUPTED;
3551 }
3552
3553 while (count) {
3554 int compr_blocks = 0;
3555
3556 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) {
3557 blkaddr = f2fs_data_blkaddr(dn);
3558
3559 if (i == 0) {
3560 if (blkaddr == COMPRESS_ADDR)
3561 continue;
3562 dn->ofs_in_node += cluster_size;
3563 goto next;
3564 }
3565
3566 if (__is_valid_data_blkaddr(blkaddr))
3567 compr_blocks++;
3568
3569 if (blkaddr != NEW_ADDR)
3570 continue;
3571
3572 f2fs_set_data_blkaddr(dn, NULL_ADDR);
3573 }
3574
3575 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, false);
3576 dec_valid_block_count(sbi, dn->inode,
3577 cluster_size - compr_blocks);
3578
3579 released_blocks += cluster_size - compr_blocks;
3580 next:
3581 count -= cluster_size;
3582 }
3583
3584 return released_blocks;
3585 }
3586
f2fs_release_compress_blocks(struct file * filp,unsigned long arg)3587 static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
3588 {
3589 struct inode *inode = file_inode(filp);
3590 struct f2fs_inode_info *fi = F2FS_I(inode);
3591 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3592 pgoff_t page_idx = 0, last_idx;
3593 unsigned int released_blocks = 0;
3594 int ret;
3595 int writecount;
3596
3597 if (!f2fs_sb_has_compression(sbi))
3598 return -EOPNOTSUPP;
3599
3600 if (f2fs_readonly(sbi->sb))
3601 return -EROFS;
3602
3603 ret = mnt_want_write_file(filp);
3604 if (ret)
3605 return ret;
3606
3607 f2fs_balance_fs(sbi, true);
3608
3609 inode_lock(inode);
3610
3611 writecount = atomic_read(&inode->i_writecount);
3612 if ((filp->f_mode & FMODE_WRITE && writecount != 1) ||
3613 (!(filp->f_mode & FMODE_WRITE) && writecount)) {
3614 ret = -EBUSY;
3615 goto out;
3616 }
3617
3618 if (!f2fs_compressed_file(inode) ||
3619 is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3620 ret = -EINVAL;
3621 goto out;
3622 }
3623
3624 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
3625 if (ret)
3626 goto out;
3627
3628 if (!atomic_read(&fi->i_compr_blocks)) {
3629 ret = -EPERM;
3630 goto out;
3631 }
3632
3633 set_inode_flag(inode, FI_COMPRESS_RELEASED);
3634 inode_set_ctime_current(inode);
3635 f2fs_mark_inode_dirty_sync(inode, true);
3636
3637 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
3638 filemap_invalidate_lock(inode->i_mapping);
3639
3640 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3641
3642 while (page_idx < last_idx) {
3643 struct dnode_of_data dn;
3644 pgoff_t end_offset, count;
3645
3646 f2fs_lock_op(sbi);
3647
3648 set_new_dnode(&dn, inode, NULL, NULL, 0);
3649 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
3650 if (ret) {
3651 f2fs_unlock_op(sbi);
3652 if (ret == -ENOENT) {
3653 page_idx = f2fs_get_next_page_offset(&dn,
3654 page_idx);
3655 ret = 0;
3656 continue;
3657 }
3658 break;
3659 }
3660
3661 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3662 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3663 count = round_up(count, fi->i_cluster_size);
3664
3665 ret = release_compress_blocks(&dn, count);
3666
3667 f2fs_put_dnode(&dn);
3668
3669 f2fs_unlock_op(sbi);
3670
3671 if (ret < 0)
3672 break;
3673
3674 page_idx += count;
3675 released_blocks += ret;
3676 }
3677
3678 filemap_invalidate_unlock(inode->i_mapping);
3679 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
3680 out:
3681 if (released_blocks)
3682 f2fs_update_time(sbi, REQ_TIME);
3683 inode_unlock(inode);
3684
3685 mnt_drop_write_file(filp);
3686
3687 if (ret >= 0) {
3688 ret = put_user(released_blocks, (u64 __user *)arg);
3689 } else if (released_blocks &&
3690 atomic_read(&fi->i_compr_blocks)) {
3691 set_sbi_flag(sbi, SBI_NEED_FSCK);
3692 f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
3693 "iblocks=%llu, released=%u, compr_blocks=%u, "
3694 "run fsck to fix.",
3695 __func__, inode->i_ino, inode->i_blocks,
3696 released_blocks,
3697 atomic_read(&fi->i_compr_blocks));
3698 }
3699
3700 return ret;
3701 }
3702
reserve_compress_blocks(struct dnode_of_data * dn,pgoff_t count,unsigned int * reserved_blocks)3703 static int reserve_compress_blocks(struct dnode_of_data *dn, pgoff_t count,
3704 unsigned int *reserved_blocks)
3705 {
3706 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
3707 int cluster_size = F2FS_I(dn->inode)->i_cluster_size;
3708 block_t blkaddr;
3709 int i;
3710
3711 for (i = 0; i < count; i++) {
3712 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3713 dn->ofs_in_node + i);
3714
3715 if (!__is_valid_data_blkaddr(blkaddr))
3716 continue;
3717 if (unlikely(!f2fs_is_valid_blkaddr(sbi, blkaddr,
3718 DATA_GENERIC_ENHANCE)))
3719 return -EFSCORRUPTED;
3720 }
3721
3722 while (count) {
3723 int compr_blocks = 0;
3724 blkcnt_t reserved = 0;
3725 blkcnt_t to_reserved;
3726 int ret;
3727
3728 for (i = 0; i < cluster_size; i++) {
3729 blkaddr = data_blkaddr(dn->inode, dn->node_page,
3730 dn->ofs_in_node + i);
3731
3732 if (i == 0) {
3733 if (blkaddr != COMPRESS_ADDR) {
3734 dn->ofs_in_node += cluster_size;
3735 goto next;
3736 }
3737 continue;
3738 }
3739
3740 /*
3741 * compressed cluster was not released due to it
3742 * fails in release_compress_blocks(), so NEW_ADDR
3743 * is a possible case.
3744 */
3745 if (blkaddr == NEW_ADDR) {
3746 reserved++;
3747 continue;
3748 }
3749 if (__is_valid_data_blkaddr(blkaddr)) {
3750 compr_blocks++;
3751 continue;
3752 }
3753 }
3754
3755 to_reserved = cluster_size - compr_blocks - reserved;
3756
3757 /* for the case all blocks in cluster were reserved */
3758 if (to_reserved == 1) {
3759 dn->ofs_in_node += cluster_size;
3760 goto next;
3761 }
3762
3763 ret = inc_valid_block_count(sbi, dn->inode,
3764 &to_reserved, false);
3765 if (unlikely(ret))
3766 return ret;
3767
3768 for (i = 0; i < cluster_size; i++, dn->ofs_in_node++) {
3769 if (f2fs_data_blkaddr(dn) == NULL_ADDR)
3770 f2fs_set_data_blkaddr(dn, NEW_ADDR);
3771 }
3772
3773 f2fs_i_compr_blocks_update(dn->inode, compr_blocks, true);
3774
3775 *reserved_blocks += to_reserved;
3776 next:
3777 count -= cluster_size;
3778 }
3779
3780 return 0;
3781 }
3782
f2fs_reserve_compress_blocks(struct file * filp,unsigned long arg)3783 static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
3784 {
3785 struct inode *inode = file_inode(filp);
3786 struct f2fs_inode_info *fi = F2FS_I(inode);
3787 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3788 pgoff_t page_idx = 0, last_idx;
3789 unsigned int reserved_blocks = 0;
3790 int ret;
3791
3792 if (!f2fs_sb_has_compression(sbi))
3793 return -EOPNOTSUPP;
3794
3795 if (f2fs_readonly(sbi->sb))
3796 return -EROFS;
3797
3798 ret = mnt_want_write_file(filp);
3799 if (ret)
3800 return ret;
3801
3802 f2fs_balance_fs(sbi, true);
3803
3804 inode_lock(inode);
3805
3806 if (!f2fs_compressed_file(inode) ||
3807 !is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
3808 ret = -EINVAL;
3809 goto unlock_inode;
3810 }
3811
3812 if (atomic_read(&fi->i_compr_blocks))
3813 goto unlock_inode;
3814
3815 f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
3816 filemap_invalidate_lock(inode->i_mapping);
3817
3818 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
3819
3820 while (page_idx < last_idx) {
3821 struct dnode_of_data dn;
3822 pgoff_t end_offset, count;
3823
3824 f2fs_lock_op(sbi);
3825
3826 set_new_dnode(&dn, inode, NULL, NULL, 0);
3827 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
3828 if (ret) {
3829 f2fs_unlock_op(sbi);
3830 if (ret == -ENOENT) {
3831 page_idx = f2fs_get_next_page_offset(&dn,
3832 page_idx);
3833 ret = 0;
3834 continue;
3835 }
3836 break;
3837 }
3838
3839 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
3840 count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3841 count = round_up(count, fi->i_cluster_size);
3842
3843 ret = reserve_compress_blocks(&dn, count, &reserved_blocks);
3844
3845 f2fs_put_dnode(&dn);
3846
3847 f2fs_unlock_op(sbi);
3848
3849 if (ret < 0)
3850 break;
3851
3852 page_idx += count;
3853 }
3854
3855 filemap_invalidate_unlock(inode->i_mapping);
3856 f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
3857
3858 if (!ret) {
3859 clear_inode_flag(inode, FI_COMPRESS_RELEASED);
3860 inode_set_ctime_current(inode);
3861 f2fs_mark_inode_dirty_sync(inode, true);
3862 }
3863 unlock_inode:
3864 if (reserved_blocks)
3865 f2fs_update_time(sbi, REQ_TIME);
3866 inode_unlock(inode);
3867 mnt_drop_write_file(filp);
3868
3869 if (!ret) {
3870 ret = put_user(reserved_blocks, (u64 __user *)arg);
3871 } else if (reserved_blocks &&
3872 atomic_read(&fi->i_compr_blocks)) {
3873 set_sbi_flag(sbi, SBI_NEED_FSCK);
3874 f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%lx "
3875 "iblocks=%llu, reserved=%u, compr_blocks=%u, "
3876 "run fsck to fix.",
3877 __func__, inode->i_ino, inode->i_blocks,
3878 reserved_blocks,
3879 atomic_read(&fi->i_compr_blocks));
3880 }
3881
3882 return ret;
3883 }
3884
f2fs_secure_erase(struct block_device * bdev,struct inode * inode,pgoff_t off,block_t block,block_t len,u32 flags)3885 static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode,
3886 pgoff_t off, block_t block, block_t len, u32 flags)
3887 {
3888 sector_t sector = SECTOR_FROM_BLOCK(block);
3889 sector_t nr_sects = SECTOR_FROM_BLOCK(len);
3890 int ret = 0;
3891
3892 if (flags & F2FS_TRIM_FILE_DISCARD) {
3893 if (bdev_max_secure_erase_sectors(bdev))
3894 ret = blkdev_issue_secure_erase(bdev, sector, nr_sects,
3895 GFP_NOFS);
3896 else
3897 ret = blkdev_issue_discard(bdev, sector, nr_sects,
3898 GFP_NOFS);
3899 }
3900
3901 if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) {
3902 if (IS_ENCRYPTED(inode))
3903 ret = fscrypt_zeroout_range(inode, off, block, len);
3904 else
3905 ret = blkdev_issue_zeroout(bdev, sector, nr_sects,
3906 GFP_NOFS, 0);
3907 }
3908
3909 return ret;
3910 }
3911
f2fs_sec_trim_file(struct file * filp,unsigned long arg)3912 static int f2fs_sec_trim_file(struct file *filp, unsigned long arg)
3913 {
3914 struct inode *inode = file_inode(filp);
3915 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3916 struct address_space *mapping = inode->i_mapping;
3917 struct block_device *prev_bdev = NULL;
3918 struct f2fs_sectrim_range range;
3919 pgoff_t index, pg_end, prev_index = 0;
3920 block_t prev_block = 0, len = 0;
3921 loff_t end_addr;
3922 bool to_end = false;
3923 int ret = 0;
3924
3925 if (!(filp->f_mode & FMODE_WRITE))
3926 return -EBADF;
3927
3928 if (copy_from_user(&range, (struct f2fs_sectrim_range __user *)arg,
3929 sizeof(range)))
3930 return -EFAULT;
3931
3932 if (range.flags == 0 || (range.flags & ~F2FS_TRIM_FILE_MASK) ||
3933 !S_ISREG(inode->i_mode))
3934 return -EINVAL;
3935
3936 if (((range.flags & F2FS_TRIM_FILE_DISCARD) &&
3937 !f2fs_hw_support_discard(sbi)) ||
3938 ((range.flags & F2FS_TRIM_FILE_ZEROOUT) &&
3939 IS_ENCRYPTED(inode) && f2fs_is_multi_device(sbi)))
3940 return -EOPNOTSUPP;
3941
3942 ret = mnt_want_write_file(filp);
3943 if (ret)
3944 return ret;
3945 inode_lock(inode);
3946
3947 if (f2fs_is_atomic_file(inode) || f2fs_compressed_file(inode) ||
3948 range.start >= inode->i_size) {
3949 ret = -EINVAL;
3950 goto err;
3951 }
3952
3953 if (range.len == 0)
3954 goto err;
3955
3956 if (inode->i_size - range.start > range.len) {
3957 end_addr = range.start + range.len;
3958 } else {
3959 end_addr = range.len == (u64)-1 ?
3960 sbi->sb->s_maxbytes : inode->i_size;
3961 to_end = true;
3962 }
3963
3964 if (!IS_ALIGNED(range.start, F2FS_BLKSIZE) ||
3965 (!to_end && !IS_ALIGNED(end_addr, F2FS_BLKSIZE))) {
3966 ret = -EINVAL;
3967 goto err;
3968 }
3969
3970 index = F2FS_BYTES_TO_BLK(range.start);
3971 pg_end = DIV_ROUND_UP(end_addr, F2FS_BLKSIZE);
3972
3973 ret = f2fs_convert_inline_inode(inode);
3974 if (ret)
3975 goto err;
3976
3977 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3978 filemap_invalidate_lock(mapping);
3979
3980 ret = filemap_write_and_wait_range(mapping, range.start,
3981 to_end ? LLONG_MAX : end_addr - 1);
3982 if (ret)
3983 goto out;
3984
3985 truncate_inode_pages_range(mapping, range.start,
3986 to_end ? -1 : end_addr - 1);
3987
3988 while (index < pg_end) {
3989 struct dnode_of_data dn;
3990 pgoff_t end_offset, count;
3991 int i;
3992
3993 set_new_dnode(&dn, inode, NULL, NULL, 0);
3994 ret = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
3995 if (ret) {
3996 if (ret == -ENOENT) {
3997 index = f2fs_get_next_page_offset(&dn, index);
3998 continue;
3999 }
4000 goto out;
4001 }
4002
4003 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
4004 count = min(end_offset - dn.ofs_in_node, pg_end - index);
4005 for (i = 0; i < count; i++, index++, dn.ofs_in_node++) {
4006 struct block_device *cur_bdev;
4007 block_t blkaddr = f2fs_data_blkaddr(&dn);
4008
4009 if (!__is_valid_data_blkaddr(blkaddr))
4010 continue;
4011
4012 if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
4013 DATA_GENERIC_ENHANCE)) {
4014 ret = -EFSCORRUPTED;
4015 f2fs_put_dnode(&dn);
4016 goto out;
4017 }
4018
4019 cur_bdev = f2fs_target_device(sbi, blkaddr, NULL);
4020 if (f2fs_is_multi_device(sbi)) {
4021 int di = f2fs_target_device_index(sbi, blkaddr);
4022
4023 blkaddr -= FDEV(di).start_blk;
4024 }
4025
4026 if (len) {
4027 if (prev_bdev == cur_bdev &&
4028 index == prev_index + len &&
4029 blkaddr == prev_block + len) {
4030 len++;
4031 } else {
4032 ret = f2fs_secure_erase(prev_bdev,
4033 inode, prev_index, prev_block,
4034 len, range.flags);
4035 if (ret) {
4036 f2fs_put_dnode(&dn);
4037 goto out;
4038 }
4039
4040 len = 0;
4041 }
4042 }
4043
4044 if (!len) {
4045 prev_bdev = cur_bdev;
4046 prev_index = index;
4047 prev_block = blkaddr;
4048 len = 1;
4049 }
4050 }
4051
4052 f2fs_put_dnode(&dn);
4053
4054 if (fatal_signal_pending(current)) {
4055 ret = -EINTR;
4056 goto out;
4057 }
4058 cond_resched();
4059 }
4060
4061 if (len)
4062 ret = f2fs_secure_erase(prev_bdev, inode, prev_index,
4063 prev_block, len, range.flags);
4064 f2fs_update_time(sbi, REQ_TIME);
4065 out:
4066 filemap_invalidate_unlock(mapping);
4067 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4068 err:
4069 inode_unlock(inode);
4070 mnt_drop_write_file(filp);
4071
4072 return ret;
4073 }
4074
f2fs_ioc_get_compress_option(struct file * filp,unsigned long arg)4075 static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg)
4076 {
4077 struct inode *inode = file_inode(filp);
4078 struct f2fs_comp_option option;
4079
4080 if (!f2fs_sb_has_compression(F2FS_I_SB(inode)))
4081 return -EOPNOTSUPP;
4082
4083 inode_lock_shared(inode);
4084
4085 if (!f2fs_compressed_file(inode)) {
4086 inode_unlock_shared(inode);
4087 return -ENODATA;
4088 }
4089
4090 option.algorithm = F2FS_I(inode)->i_compress_algorithm;
4091 option.log_cluster_size = F2FS_I(inode)->i_log_cluster_size;
4092
4093 inode_unlock_shared(inode);
4094
4095 if (copy_to_user((struct f2fs_comp_option __user *)arg, &option,
4096 sizeof(option)))
4097 return -EFAULT;
4098
4099 return 0;
4100 }
4101
f2fs_ioc_set_compress_option(struct file * filp,unsigned long arg)4102 static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg)
4103 {
4104 struct inode *inode = file_inode(filp);
4105 struct f2fs_inode_info *fi = F2FS_I(inode);
4106 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4107 struct f2fs_comp_option option;
4108 int ret = 0;
4109
4110 if (!f2fs_sb_has_compression(sbi))
4111 return -EOPNOTSUPP;
4112
4113 if (!(filp->f_mode & FMODE_WRITE))
4114 return -EBADF;
4115
4116 if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg,
4117 sizeof(option)))
4118 return -EFAULT;
4119
4120 if (option.log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
4121 option.log_cluster_size > MAX_COMPRESS_LOG_SIZE ||
4122 option.algorithm >= COMPRESS_MAX)
4123 return -EINVAL;
4124
4125 ret = mnt_want_write_file(filp);
4126 if (ret)
4127 return ret;
4128 inode_lock(inode);
4129
4130 f2fs_down_write(&F2FS_I(inode)->i_sem);
4131 if (!f2fs_compressed_file(inode)) {
4132 ret = -EINVAL;
4133 goto out;
4134 }
4135
4136 if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) {
4137 ret = -EBUSY;
4138 goto out;
4139 }
4140
4141 if (F2FS_HAS_BLOCKS(inode)) {
4142 ret = -EFBIG;
4143 goto out;
4144 }
4145
4146 fi->i_compress_algorithm = option.algorithm;
4147 fi->i_log_cluster_size = option.log_cluster_size;
4148 fi->i_cluster_size = BIT(option.log_cluster_size);
4149 /* Set default level */
4150 if (fi->i_compress_algorithm == COMPRESS_ZSTD)
4151 fi->i_compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
4152 else
4153 fi->i_compress_level = 0;
4154 /* Adjust mount option level */
4155 if (option.algorithm == F2FS_OPTION(sbi).compress_algorithm &&
4156 F2FS_OPTION(sbi).compress_level)
4157 fi->i_compress_level = F2FS_OPTION(sbi).compress_level;
4158 f2fs_mark_inode_dirty_sync(inode, true);
4159
4160 if (!f2fs_is_compress_backend_ready(inode))
4161 f2fs_warn(sbi, "compression algorithm is successfully set, "
4162 "but current kernel doesn't support this algorithm.");
4163 out:
4164 f2fs_up_write(&fi->i_sem);
4165 inode_unlock(inode);
4166 mnt_drop_write_file(filp);
4167
4168 return ret;
4169 }
4170
redirty_blocks(struct inode * inode,pgoff_t page_idx,int len)4171 static int redirty_blocks(struct inode *inode, pgoff_t page_idx, int len)
4172 {
4173 DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, page_idx);
4174 struct address_space *mapping = inode->i_mapping;
4175 struct page *page;
4176 pgoff_t redirty_idx = page_idx;
4177 int i, page_len = 0, ret = 0;
4178
4179 page_cache_ra_unbounded(&ractl, len, 0);
4180
4181 for (i = 0; i < len; i++, page_idx++) {
4182 page = read_cache_page(mapping, page_idx, NULL, NULL);
4183 if (IS_ERR(page)) {
4184 ret = PTR_ERR(page);
4185 break;
4186 }
4187 page_len++;
4188 }
4189
4190 for (i = 0; i < page_len; i++, redirty_idx++) {
4191 page = find_lock_page(mapping, redirty_idx);
4192
4193 /* It will never fail, when page has pinned above */
4194 f2fs_bug_on(F2FS_I_SB(inode), !page);
4195
4196 set_page_dirty(page);
4197 set_page_private_gcing(page);
4198 f2fs_put_page(page, 1);
4199 f2fs_put_page(page, 0);
4200 }
4201
4202 return ret;
4203 }
4204
f2fs_ioc_decompress_file(struct file * filp)4205 static int f2fs_ioc_decompress_file(struct file *filp)
4206 {
4207 struct inode *inode = file_inode(filp);
4208 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4209 struct f2fs_inode_info *fi = F2FS_I(inode);
4210 pgoff_t page_idx = 0, last_idx;
4211 int cluster_size = fi->i_cluster_size;
4212 int count, ret;
4213
4214 if (!f2fs_sb_has_compression(sbi) ||
4215 F2FS_OPTION(sbi).compress_mode != COMPR_MODE_USER)
4216 return -EOPNOTSUPP;
4217
4218 if (!(filp->f_mode & FMODE_WRITE))
4219 return -EBADF;
4220
4221 f2fs_balance_fs(sbi, true);
4222
4223 ret = mnt_want_write_file(filp);
4224 if (ret)
4225 return ret;
4226 inode_lock(inode);
4227
4228 if (!f2fs_is_compress_backend_ready(inode)) {
4229 ret = -EOPNOTSUPP;
4230 goto out;
4231 }
4232
4233 if (!f2fs_compressed_file(inode) ||
4234 is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
4235 ret = -EINVAL;
4236 goto out;
4237 }
4238
4239 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
4240 if (ret)
4241 goto out;
4242
4243 if (!atomic_read(&fi->i_compr_blocks))
4244 goto out;
4245
4246 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
4247
4248 count = last_idx - page_idx;
4249 while (count && count >= cluster_size) {
4250 ret = redirty_blocks(inode, page_idx, cluster_size);
4251 if (ret < 0)
4252 break;
4253
4254 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) {
4255 ret = filemap_fdatawrite(inode->i_mapping);
4256 if (ret < 0)
4257 break;
4258 }
4259
4260 count -= cluster_size;
4261 page_idx += cluster_size;
4262
4263 cond_resched();
4264 if (fatal_signal_pending(current)) {
4265 ret = -EINTR;
4266 break;
4267 }
4268 }
4269
4270 if (!ret)
4271 ret = filemap_write_and_wait_range(inode->i_mapping, 0,
4272 LLONG_MAX);
4273
4274 if (ret)
4275 f2fs_warn(sbi, "%s: The file might be partially decompressed (errno=%d). Please delete the file.",
4276 __func__, ret);
4277 f2fs_update_time(sbi, REQ_TIME);
4278 out:
4279 inode_unlock(inode);
4280 mnt_drop_write_file(filp);
4281
4282 return ret;
4283 }
4284
f2fs_ioc_compress_file(struct file * filp)4285 static int f2fs_ioc_compress_file(struct file *filp)
4286 {
4287 struct inode *inode = file_inode(filp);
4288 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4289 pgoff_t page_idx = 0, last_idx;
4290 int cluster_size = F2FS_I(inode)->i_cluster_size;
4291 int count, ret;
4292
4293 if (!f2fs_sb_has_compression(sbi) ||
4294 F2FS_OPTION(sbi).compress_mode != COMPR_MODE_USER)
4295 return -EOPNOTSUPP;
4296
4297 if (!(filp->f_mode & FMODE_WRITE))
4298 return -EBADF;
4299
4300 f2fs_balance_fs(sbi, true);
4301
4302 ret = mnt_want_write_file(filp);
4303 if (ret)
4304 return ret;
4305 inode_lock(inode);
4306
4307 if (!f2fs_is_compress_backend_ready(inode)) {
4308 ret = -EOPNOTSUPP;
4309 goto out;
4310 }
4311
4312 if (!f2fs_compressed_file(inode) ||
4313 is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
4314 ret = -EINVAL;
4315 goto out;
4316 }
4317
4318 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
4319 if (ret)
4320 goto out;
4321
4322 set_inode_flag(inode, FI_ENABLE_COMPRESS);
4323
4324 last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
4325
4326 count = last_idx - page_idx;
4327 while (count && count >= cluster_size) {
4328 ret = redirty_blocks(inode, page_idx, cluster_size);
4329 if (ret < 0)
4330 break;
4331
4332 if (get_dirty_pages(inode) >= BLKS_PER_SEG(sbi)) {
4333 ret = filemap_fdatawrite(inode->i_mapping);
4334 if (ret < 0)
4335 break;
4336 }
4337
4338 count -= cluster_size;
4339 page_idx += cluster_size;
4340
4341 cond_resched();
4342 if (fatal_signal_pending(current)) {
4343 ret = -EINTR;
4344 break;
4345 }
4346 }
4347
4348 if (!ret)
4349 ret = filemap_write_and_wait_range(inode->i_mapping, 0,
4350 LLONG_MAX);
4351
4352 clear_inode_flag(inode, FI_ENABLE_COMPRESS);
4353
4354 if (ret)
4355 f2fs_warn(sbi, "%s: The file might be partially compressed (errno=%d). Please delete the file.",
4356 __func__, ret);
4357 f2fs_update_time(sbi, REQ_TIME);
4358 out:
4359 inode_unlock(inode);
4360 mnt_drop_write_file(filp);
4361
4362 return ret;
4363 }
4364
__f2fs_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)4365 static long __f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
4366 {
4367 switch (cmd) {
4368 case FS_IOC_GETVERSION:
4369 return f2fs_ioc_getversion(filp, arg);
4370 case F2FS_IOC_START_ATOMIC_WRITE:
4371 return f2fs_ioc_start_atomic_write(filp, false);
4372 case F2FS_IOC_START_ATOMIC_REPLACE:
4373 return f2fs_ioc_start_atomic_write(filp, true);
4374 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
4375 return f2fs_ioc_commit_atomic_write(filp);
4376 case F2FS_IOC_ABORT_ATOMIC_WRITE:
4377 return f2fs_ioc_abort_atomic_write(filp);
4378 case F2FS_IOC_START_VOLATILE_WRITE:
4379 case F2FS_IOC_RELEASE_VOLATILE_WRITE:
4380 return -EOPNOTSUPP;
4381 case F2FS_IOC_SHUTDOWN:
4382 return f2fs_ioc_shutdown(filp, arg);
4383 case FITRIM:
4384 return f2fs_ioc_fitrim(filp, arg);
4385 case FS_IOC_SET_ENCRYPTION_POLICY:
4386 return f2fs_ioc_set_encryption_policy(filp, arg);
4387 case FS_IOC_GET_ENCRYPTION_POLICY:
4388 return f2fs_ioc_get_encryption_policy(filp, arg);
4389 case FS_IOC_GET_ENCRYPTION_PWSALT:
4390 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
4391 case FS_IOC_GET_ENCRYPTION_POLICY_EX:
4392 return f2fs_ioc_get_encryption_policy_ex(filp, arg);
4393 case FS_IOC_ADD_ENCRYPTION_KEY:
4394 return f2fs_ioc_add_encryption_key(filp, arg);
4395 case FS_IOC_REMOVE_ENCRYPTION_KEY:
4396 return f2fs_ioc_remove_encryption_key(filp, arg);
4397 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
4398 return f2fs_ioc_remove_encryption_key_all_users(filp, arg);
4399 case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
4400 return f2fs_ioc_get_encryption_key_status(filp, arg);
4401 case FS_IOC_GET_ENCRYPTION_NONCE:
4402 return f2fs_ioc_get_encryption_nonce(filp, arg);
4403 case F2FS_IOC_GARBAGE_COLLECT:
4404 return f2fs_ioc_gc(filp, arg);
4405 case F2FS_IOC_GARBAGE_COLLECT_RANGE:
4406 return f2fs_ioc_gc_range(filp, arg);
4407 case F2FS_IOC_WRITE_CHECKPOINT:
4408 return f2fs_ioc_write_checkpoint(filp);
4409 case F2FS_IOC_DEFRAGMENT:
4410 return f2fs_ioc_defragment(filp, arg);
4411 case F2FS_IOC_MOVE_RANGE:
4412 return f2fs_ioc_move_range(filp, arg);
4413 case F2FS_IOC_FLUSH_DEVICE:
4414 return f2fs_ioc_flush_device(filp, arg);
4415 case F2FS_IOC_GET_FEATURES:
4416 return f2fs_ioc_get_features(filp, arg);
4417 case F2FS_IOC_GET_PIN_FILE:
4418 return f2fs_ioc_get_pin_file(filp, arg);
4419 case F2FS_IOC_SET_PIN_FILE:
4420 return f2fs_ioc_set_pin_file(filp, arg);
4421 case F2FS_IOC_PRECACHE_EXTENTS:
4422 return f2fs_ioc_precache_extents(filp);
4423 case F2FS_IOC_RESIZE_FS:
4424 return f2fs_ioc_resize_fs(filp, arg);
4425 case FS_IOC_ENABLE_VERITY:
4426 return f2fs_ioc_enable_verity(filp, arg);
4427 case FS_IOC_MEASURE_VERITY:
4428 return f2fs_ioc_measure_verity(filp, arg);
4429 case FS_IOC_READ_VERITY_METADATA:
4430 return f2fs_ioc_read_verity_metadata(filp, arg);
4431 case FS_IOC_GETFSLABEL:
4432 return f2fs_ioc_getfslabel(filp, arg);
4433 case FS_IOC_SETFSLABEL:
4434 return f2fs_ioc_setfslabel(filp, arg);
4435 case F2FS_IOC_GET_COMPRESS_BLOCKS:
4436 return f2fs_ioc_get_compress_blocks(filp, arg);
4437 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
4438 return f2fs_release_compress_blocks(filp, arg);
4439 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
4440 return f2fs_reserve_compress_blocks(filp, arg);
4441 case F2FS_IOC_SEC_TRIM_FILE:
4442 return f2fs_sec_trim_file(filp, arg);
4443 case F2FS_IOC_GET_COMPRESS_OPTION:
4444 return f2fs_ioc_get_compress_option(filp, arg);
4445 case F2FS_IOC_SET_COMPRESS_OPTION:
4446 return f2fs_ioc_set_compress_option(filp, arg);
4447 case F2FS_IOC_DECOMPRESS_FILE:
4448 return f2fs_ioc_decompress_file(filp);
4449 case F2FS_IOC_COMPRESS_FILE:
4450 return f2fs_ioc_compress_file(filp);
4451 default:
4452 return -ENOTTY;
4453 }
4454 }
4455
f2fs_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)4456 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
4457 {
4458 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
4459 return -EIO;
4460 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp))))
4461 return -ENOSPC;
4462
4463 return __f2fs_ioctl(filp, cmd, arg);
4464 }
4465
4466 /*
4467 * Return %true if the given read or write request should use direct I/O, or
4468 * %false if it should use buffered I/O.
4469 */
f2fs_should_use_dio(struct inode * inode,struct kiocb * iocb,struct iov_iter * iter)4470 static bool f2fs_should_use_dio(struct inode *inode, struct kiocb *iocb,
4471 struct iov_iter *iter)
4472 {
4473 unsigned int align;
4474
4475 if (!(iocb->ki_flags & IOCB_DIRECT))
4476 return false;
4477
4478 if (f2fs_force_buffered_io(inode, iov_iter_rw(iter)))
4479 return false;
4480
4481 /*
4482 * Direct I/O not aligned to the disk's logical_block_size will be
4483 * attempted, but will fail with -EINVAL.
4484 *
4485 * f2fs additionally requires that direct I/O be aligned to the
4486 * filesystem block size, which is often a stricter requirement.
4487 * However, f2fs traditionally falls back to buffered I/O on requests
4488 * that are logical_block_size-aligned but not fs-block aligned.
4489 *
4490 * The below logic implements this behavior.
4491 */
4492 align = iocb->ki_pos | iov_iter_alignment(iter);
4493 if (!IS_ALIGNED(align, i_blocksize(inode)) &&
4494 IS_ALIGNED(align, bdev_logical_block_size(inode->i_sb->s_bdev)))
4495 return false;
4496
4497 return true;
4498 }
4499
f2fs_dio_read_end_io(struct kiocb * iocb,ssize_t size,int error,unsigned int flags)4500 static int f2fs_dio_read_end_io(struct kiocb *iocb, ssize_t size, int error,
4501 unsigned int flags)
4502 {
4503 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp));
4504
4505 dec_page_count(sbi, F2FS_DIO_READ);
4506 if (error)
4507 return error;
4508 f2fs_update_iostat(sbi, NULL, APP_DIRECT_READ_IO, size);
4509 return 0;
4510 }
4511
4512 static const struct iomap_dio_ops f2fs_iomap_dio_read_ops = {
4513 .end_io = f2fs_dio_read_end_io,
4514 };
4515
f2fs_dio_read_iter(struct kiocb * iocb,struct iov_iter * to)4516 static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
4517 {
4518 struct file *file = iocb->ki_filp;
4519 struct inode *inode = file_inode(file);
4520 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4521 struct f2fs_inode_info *fi = F2FS_I(inode);
4522 const loff_t pos = iocb->ki_pos;
4523 const size_t count = iov_iter_count(to);
4524 struct iomap_dio *dio;
4525 ssize_t ret;
4526
4527 if (count == 0)
4528 return 0; /* skip atime update */
4529
4530 trace_f2fs_direct_IO_enter(inode, iocb, count, READ);
4531
4532 if (iocb->ki_flags & IOCB_NOWAIT) {
4533 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4534 ret = -EAGAIN;
4535 goto out;
4536 }
4537 } else {
4538 f2fs_down_read(&fi->i_gc_rwsem[READ]);
4539 }
4540
4541 /*
4542 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4543 * the higher-level function iomap_dio_rw() in order to ensure that the
4544 * F2FS_DIO_READ counter will be decremented correctly in all cases.
4545 */
4546 inc_page_count(sbi, F2FS_DIO_READ);
4547 dio = __iomap_dio_rw(iocb, to, &f2fs_iomap_ops,
4548 &f2fs_iomap_dio_read_ops, 0, NULL, 0);
4549 if (IS_ERR_OR_NULL(dio)) {
4550 ret = PTR_ERR_OR_ZERO(dio);
4551 if (ret != -EIOCBQUEUED)
4552 dec_page_count(sbi, F2FS_DIO_READ);
4553 } else {
4554 ret = iomap_dio_complete(dio);
4555 }
4556
4557 f2fs_up_read(&fi->i_gc_rwsem[READ]);
4558
4559 file_accessed(file);
4560 out:
4561 trace_f2fs_direct_IO_exit(inode, pos, count, READ, ret);
4562 return ret;
4563 }
4564
f2fs_trace_rw_file_path(struct file * file,loff_t pos,size_t count,int rw)4565 static void f2fs_trace_rw_file_path(struct file *file, loff_t pos, size_t count,
4566 int rw)
4567 {
4568 struct inode *inode = file_inode(file);
4569 char *buf, *path;
4570
4571 buf = f2fs_getname(F2FS_I_SB(inode));
4572 if (!buf)
4573 return;
4574 path = dentry_path_raw(file_dentry(file), buf, PATH_MAX);
4575 if (IS_ERR(path))
4576 goto free_buf;
4577 if (rw == WRITE)
4578 trace_f2fs_datawrite_start(inode, pos, count,
4579 current->pid, path, current->comm);
4580 else
4581 trace_f2fs_dataread_start(inode, pos, count,
4582 current->pid, path, current->comm);
4583 free_buf:
4584 f2fs_putname(buf);
4585 }
4586
f2fs_file_read_iter(struct kiocb * iocb,struct iov_iter * to)4587 static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
4588 {
4589 struct inode *inode = file_inode(iocb->ki_filp);
4590 const loff_t pos = iocb->ki_pos;
4591 ssize_t ret;
4592
4593 if (!f2fs_is_compress_backend_ready(inode))
4594 return -EOPNOTSUPP;
4595
4596 if (trace_f2fs_dataread_start_enabled())
4597 f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos,
4598 iov_iter_count(to), READ);
4599
4600 if (f2fs_should_use_dio(inode, iocb, to)) {
4601 ret = f2fs_dio_read_iter(iocb, to);
4602 } else {
4603 ret = filemap_read(iocb, to, 0);
4604 if (ret > 0)
4605 f2fs_update_iostat(F2FS_I_SB(inode), inode,
4606 APP_BUFFERED_READ_IO, ret);
4607 }
4608 if (trace_f2fs_dataread_end_enabled())
4609 trace_f2fs_dataread_end(inode, pos, ret);
4610 return ret;
4611 }
4612
f2fs_file_splice_read(struct file * in,loff_t * ppos,struct pipe_inode_info * pipe,size_t len,unsigned int flags)4613 static ssize_t f2fs_file_splice_read(struct file *in, loff_t *ppos,
4614 struct pipe_inode_info *pipe,
4615 size_t len, unsigned int flags)
4616 {
4617 struct inode *inode = file_inode(in);
4618 const loff_t pos = *ppos;
4619 ssize_t ret;
4620
4621 if (!f2fs_is_compress_backend_ready(inode))
4622 return -EOPNOTSUPP;
4623
4624 if (trace_f2fs_dataread_start_enabled())
4625 f2fs_trace_rw_file_path(in, pos, len, READ);
4626
4627 ret = filemap_splice_read(in, ppos, pipe, len, flags);
4628 if (ret > 0)
4629 f2fs_update_iostat(F2FS_I_SB(inode), inode,
4630 APP_BUFFERED_READ_IO, ret);
4631
4632 if (trace_f2fs_dataread_end_enabled())
4633 trace_f2fs_dataread_end(inode, pos, ret);
4634 return ret;
4635 }
4636
f2fs_write_checks(struct kiocb * iocb,struct iov_iter * from)4637 static ssize_t f2fs_write_checks(struct kiocb *iocb, struct iov_iter *from)
4638 {
4639 struct file *file = iocb->ki_filp;
4640 struct inode *inode = file_inode(file);
4641 ssize_t count;
4642 int err;
4643
4644 if (IS_IMMUTABLE(inode))
4645 return -EPERM;
4646
4647 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
4648 return -EPERM;
4649
4650 count = generic_write_checks(iocb, from);
4651 if (count <= 0)
4652 return count;
4653
4654 err = file_modified(file);
4655 if (err)
4656 return err;
4657 return count;
4658 }
4659
4660 /*
4661 * Preallocate blocks for a write request, if it is possible and helpful to do
4662 * so. Returns a positive number if blocks may have been preallocated, 0 if no
4663 * blocks were preallocated, or a negative errno value if something went
4664 * seriously wrong. Also sets FI_PREALLOCATED_ALL on the inode if *all* the
4665 * requested blocks (not just some of them) have been allocated.
4666 */
f2fs_preallocate_blocks(struct kiocb * iocb,struct iov_iter * iter,bool dio)4667 static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
4668 bool dio)
4669 {
4670 struct inode *inode = file_inode(iocb->ki_filp);
4671 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4672 const loff_t pos = iocb->ki_pos;
4673 const size_t count = iov_iter_count(iter);
4674 struct f2fs_map_blocks map = {};
4675 int flag;
4676 int ret;
4677
4678 /* If it will be an out-of-place direct write, don't bother. */
4679 if (dio && f2fs_lfs_mode(sbi))
4680 return 0;
4681 /*
4682 * Don't preallocate holes aligned to DIO_SKIP_HOLES which turns into
4683 * buffered IO, if DIO meets any holes.
4684 */
4685 if (dio && i_size_read(inode) &&
4686 (F2FS_BYTES_TO_BLK(pos) < F2FS_BLK_ALIGN(i_size_read(inode))))
4687 return 0;
4688
4689 /* No-wait I/O can't allocate blocks. */
4690 if (iocb->ki_flags & IOCB_NOWAIT)
4691 return 0;
4692
4693 /* If it will be a short write, don't bother. */
4694 if (fault_in_iov_iter_readable(iter, count))
4695 return 0;
4696
4697 if (f2fs_has_inline_data(inode)) {
4698 /* If the data will fit inline, don't bother. */
4699 if (pos + count <= MAX_INLINE_DATA(inode))
4700 return 0;
4701 ret = f2fs_convert_inline_inode(inode);
4702 if (ret)
4703 return ret;
4704 }
4705
4706 /* Do not preallocate blocks that will be written partially in 4KB. */
4707 map.m_lblk = F2FS_BLK_ALIGN(pos);
4708 map.m_len = F2FS_BYTES_TO_BLK(pos + count);
4709 if (map.m_len > map.m_lblk)
4710 map.m_len -= map.m_lblk;
4711 else
4712 return 0;
4713
4714 map.m_may_create = true;
4715 if (dio) {
4716 map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
4717 inode->i_write_hint);
4718 flag = F2FS_GET_BLOCK_PRE_DIO;
4719 } else {
4720 map.m_seg_type = NO_CHECK_TYPE;
4721 flag = F2FS_GET_BLOCK_PRE_AIO;
4722 }
4723
4724 ret = f2fs_map_blocks(inode, &map, flag);
4725 /* -ENOSPC|-EDQUOT are fine to report the number of allocated blocks. */
4726 if (ret < 0 && !((ret == -ENOSPC || ret == -EDQUOT) && map.m_len > 0))
4727 return ret;
4728 if (ret == 0)
4729 set_inode_flag(inode, FI_PREALLOCATED_ALL);
4730 return map.m_len;
4731 }
4732
f2fs_buffered_write_iter(struct kiocb * iocb,struct iov_iter * from)4733 static ssize_t f2fs_buffered_write_iter(struct kiocb *iocb,
4734 struct iov_iter *from)
4735 {
4736 struct file *file = iocb->ki_filp;
4737 struct inode *inode = file_inode(file);
4738 ssize_t ret;
4739
4740 if (iocb->ki_flags & IOCB_NOWAIT)
4741 return -EOPNOTSUPP;
4742
4743 ret = generic_perform_write(iocb, from);
4744
4745 if (ret > 0) {
4746 f2fs_update_iostat(F2FS_I_SB(inode), inode,
4747 APP_BUFFERED_IO, ret);
4748 }
4749 return ret;
4750 }
4751
f2fs_dio_write_end_io(struct kiocb * iocb,ssize_t size,int error,unsigned int flags)4752 static int f2fs_dio_write_end_io(struct kiocb *iocb, ssize_t size, int error,
4753 unsigned int flags)
4754 {
4755 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(iocb->ki_filp));
4756
4757 dec_page_count(sbi, F2FS_DIO_WRITE);
4758 if (error)
4759 return error;
4760 f2fs_update_time(sbi, REQ_TIME);
4761 f2fs_update_iostat(sbi, NULL, APP_DIRECT_IO, size);
4762 return 0;
4763 }
4764
f2fs_dio_write_submit_io(const struct iomap_iter * iter,struct bio * bio,loff_t file_offset)4765 static void f2fs_dio_write_submit_io(const struct iomap_iter *iter,
4766 struct bio *bio, loff_t file_offset)
4767 {
4768 struct inode *inode = iter->inode;
4769 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4770 int seg_type = f2fs_rw_hint_to_seg_type(sbi, inode->i_write_hint);
4771 enum temp_type temp = f2fs_get_segment_temp(seg_type);
4772
4773 bio->bi_write_hint = f2fs_io_type_to_rw_hint(sbi, DATA, temp);
4774 submit_bio(bio);
4775 }
4776
4777 static const struct iomap_dio_ops f2fs_iomap_dio_write_ops = {
4778 .end_io = f2fs_dio_write_end_io,
4779 .submit_io = f2fs_dio_write_submit_io,
4780 };
4781
f2fs_flush_buffered_write(struct address_space * mapping,loff_t start_pos,loff_t end_pos)4782 static void f2fs_flush_buffered_write(struct address_space *mapping,
4783 loff_t start_pos, loff_t end_pos)
4784 {
4785 int ret;
4786
4787 ret = filemap_write_and_wait_range(mapping, start_pos, end_pos);
4788 if (ret < 0)
4789 return;
4790 invalidate_mapping_pages(mapping,
4791 start_pos >> PAGE_SHIFT,
4792 end_pos >> PAGE_SHIFT);
4793 }
4794
f2fs_dio_write_iter(struct kiocb * iocb,struct iov_iter * from,bool * may_need_sync)4795 static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,
4796 bool *may_need_sync)
4797 {
4798 struct file *file = iocb->ki_filp;
4799 struct inode *inode = file_inode(file);
4800 struct f2fs_inode_info *fi = F2FS_I(inode);
4801 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4802 const bool do_opu = f2fs_lfs_mode(sbi);
4803 const loff_t pos = iocb->ki_pos;
4804 const ssize_t count = iov_iter_count(from);
4805 unsigned int dio_flags;
4806 struct iomap_dio *dio;
4807 ssize_t ret;
4808
4809 trace_f2fs_direct_IO_enter(inode, iocb, count, WRITE);
4810
4811 if (iocb->ki_flags & IOCB_NOWAIT) {
4812 /* f2fs_convert_inline_inode() and block allocation can block */
4813 if (f2fs_has_inline_data(inode) ||
4814 !f2fs_overwrite_io(inode, pos, count)) {
4815 ret = -EAGAIN;
4816 goto out;
4817 }
4818
4819 if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
4820 ret = -EAGAIN;
4821 goto out;
4822 }
4823 if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
4824 f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4825 ret = -EAGAIN;
4826 goto out;
4827 }
4828 } else {
4829 ret = f2fs_convert_inline_inode(inode);
4830 if (ret)
4831 goto out;
4832
4833 f2fs_down_read(&fi->i_gc_rwsem[WRITE]);
4834 if (do_opu)
4835 f2fs_down_read(&fi->i_gc_rwsem[READ]);
4836 }
4837
4838 /*
4839 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
4840 * the higher-level function iomap_dio_rw() in order to ensure that the
4841 * F2FS_DIO_WRITE counter will be decremented correctly in all cases.
4842 */
4843 inc_page_count(sbi, F2FS_DIO_WRITE);
4844 dio_flags = 0;
4845 if (pos + count > inode->i_size)
4846 dio_flags |= IOMAP_DIO_FORCE_WAIT;
4847 dio = __iomap_dio_rw(iocb, from, &f2fs_iomap_ops,
4848 &f2fs_iomap_dio_write_ops, dio_flags, NULL, 0);
4849 if (IS_ERR_OR_NULL(dio)) {
4850 ret = PTR_ERR_OR_ZERO(dio);
4851 if (ret == -ENOTBLK)
4852 ret = 0;
4853 if (ret != -EIOCBQUEUED)
4854 dec_page_count(sbi, F2FS_DIO_WRITE);
4855 } else {
4856 ret = iomap_dio_complete(dio);
4857 }
4858
4859 if (do_opu)
4860 f2fs_up_read(&fi->i_gc_rwsem[READ]);
4861 f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
4862
4863 if (ret < 0)
4864 goto out;
4865 if (pos + ret > inode->i_size)
4866 f2fs_i_size_write(inode, pos + ret);
4867 if (!do_opu)
4868 set_inode_flag(inode, FI_UPDATE_WRITE);
4869
4870 if (iov_iter_count(from)) {
4871 ssize_t ret2;
4872 loff_t bufio_start_pos = iocb->ki_pos;
4873
4874 /*
4875 * The direct write was partial, so we need to fall back to a
4876 * buffered write for the remainder.
4877 */
4878
4879 ret2 = f2fs_buffered_write_iter(iocb, from);
4880 if (iov_iter_count(from))
4881 f2fs_write_failed(inode, iocb->ki_pos);
4882 if (ret2 < 0)
4883 goto out;
4884
4885 /*
4886 * Ensure that the pagecache pages are written to disk and
4887 * invalidated to preserve the expected O_DIRECT semantics.
4888 */
4889 if (ret2 > 0) {
4890 loff_t bufio_end_pos = bufio_start_pos + ret2 - 1;
4891
4892 ret += ret2;
4893
4894 f2fs_flush_buffered_write(file->f_mapping,
4895 bufio_start_pos,
4896 bufio_end_pos);
4897 }
4898 } else {
4899 /* iomap_dio_rw() already handled the generic_write_sync(). */
4900 *may_need_sync = false;
4901 }
4902 out:
4903 trace_f2fs_direct_IO_exit(inode, pos, count, WRITE, ret);
4904 return ret;
4905 }
4906
f2fs_file_write_iter(struct kiocb * iocb,struct iov_iter * from)4907 static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
4908 {
4909 struct inode *inode = file_inode(iocb->ki_filp);
4910 const loff_t orig_pos = iocb->ki_pos;
4911 const size_t orig_count = iov_iter_count(from);
4912 loff_t target_size;
4913 bool dio;
4914 bool may_need_sync = true;
4915 int preallocated;
4916 const loff_t pos = iocb->ki_pos;
4917 const ssize_t count = iov_iter_count(from);
4918 ssize_t ret;
4919
4920 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
4921 ret = -EIO;
4922 goto out;
4923 }
4924
4925 if (!f2fs_is_compress_backend_ready(inode)) {
4926 ret = -EOPNOTSUPP;
4927 goto out;
4928 }
4929
4930 if (iocb->ki_flags & IOCB_NOWAIT) {
4931 if (!inode_trylock(inode)) {
4932 ret = -EAGAIN;
4933 goto out;
4934 }
4935 } else {
4936 inode_lock(inode);
4937 }
4938
4939 if (f2fs_is_pinned_file(inode) &&
4940 !f2fs_overwrite_io(inode, pos, count)) {
4941 ret = -EIO;
4942 goto out_unlock;
4943 }
4944
4945 ret = f2fs_write_checks(iocb, from);
4946 if (ret <= 0)
4947 goto out_unlock;
4948
4949 /* Determine whether we will do a direct write or a buffered write. */
4950 dio = f2fs_should_use_dio(inode, iocb, from);
4951
4952 /* Possibly preallocate the blocks for the write. */
4953 target_size = iocb->ki_pos + iov_iter_count(from);
4954 preallocated = f2fs_preallocate_blocks(iocb, from, dio);
4955 if (preallocated < 0) {
4956 ret = preallocated;
4957 } else {
4958 if (trace_f2fs_datawrite_start_enabled())
4959 f2fs_trace_rw_file_path(iocb->ki_filp, iocb->ki_pos,
4960 orig_count, WRITE);
4961
4962 /* Do the actual write. */
4963 ret = dio ?
4964 f2fs_dio_write_iter(iocb, from, &may_need_sync) :
4965 f2fs_buffered_write_iter(iocb, from);
4966
4967 if (trace_f2fs_datawrite_end_enabled())
4968 trace_f2fs_datawrite_end(inode, orig_pos, ret);
4969 }
4970
4971 /* Don't leave any preallocated blocks around past i_size. */
4972 if (preallocated && i_size_read(inode) < target_size) {
4973 f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4974 filemap_invalidate_lock(inode->i_mapping);
4975 if (!f2fs_truncate(inode))
4976 file_dont_truncate(inode);
4977 filemap_invalidate_unlock(inode->i_mapping);
4978 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
4979 } else {
4980 file_dont_truncate(inode);
4981 }
4982
4983 clear_inode_flag(inode, FI_PREALLOCATED_ALL);
4984 out_unlock:
4985 inode_unlock(inode);
4986 out:
4987 trace_f2fs_file_write_iter(inode, orig_pos, orig_count, ret);
4988
4989 if (ret > 0 && may_need_sync)
4990 ret = generic_write_sync(iocb, ret);
4991
4992 /* If buffered IO was forced, flush and drop the data from
4993 * the page cache to preserve O_DIRECT semantics
4994 */
4995 if (ret > 0 && !dio && (iocb->ki_flags & IOCB_DIRECT))
4996 f2fs_flush_buffered_write(iocb->ki_filp->f_mapping,
4997 orig_pos,
4998 orig_pos + ret - 1);
4999
5000 return ret;
5001 }
5002
f2fs_file_fadvise(struct file * filp,loff_t offset,loff_t len,int advice)5003 static int f2fs_file_fadvise(struct file *filp, loff_t offset, loff_t len,
5004 int advice)
5005 {
5006 struct address_space *mapping;
5007 struct backing_dev_info *bdi;
5008 struct inode *inode = file_inode(filp);
5009 int err;
5010
5011 if (advice == POSIX_FADV_SEQUENTIAL) {
5012 if (S_ISFIFO(inode->i_mode))
5013 return -ESPIPE;
5014
5015 mapping = filp->f_mapping;
5016 if (!mapping || len < 0)
5017 return -EINVAL;
5018
5019 bdi = inode_to_bdi(mapping->host);
5020 filp->f_ra.ra_pages = bdi->ra_pages *
5021 F2FS_I_SB(inode)->seq_file_ra_mul;
5022 spin_lock(&filp->f_lock);
5023 filp->f_mode &= ~FMODE_RANDOM;
5024 spin_unlock(&filp->f_lock);
5025 return 0;
5026 } else if (advice == POSIX_FADV_WILLNEED && offset == 0) {
5027 /* Load extent cache at the first readahead. */
5028 f2fs_precache_extents(inode);
5029 }
5030
5031 err = generic_fadvise(filp, offset, len, advice);
5032 if (!err && advice == POSIX_FADV_DONTNEED &&
5033 test_opt(F2FS_I_SB(inode), COMPRESS_CACHE) &&
5034 f2fs_compressed_file(inode))
5035 f2fs_invalidate_compress_pages(F2FS_I_SB(inode), inode->i_ino);
5036
5037 return err;
5038 }
5039
5040 #ifdef CONFIG_COMPAT
5041 struct compat_f2fs_gc_range {
5042 u32 sync;
5043 compat_u64 start;
5044 compat_u64 len;
5045 };
5046 #define F2FS_IOC32_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11,\
5047 struct compat_f2fs_gc_range)
5048
f2fs_compat_ioc_gc_range(struct file * file,unsigned long arg)5049 static int f2fs_compat_ioc_gc_range(struct file *file, unsigned long arg)
5050 {
5051 struct compat_f2fs_gc_range __user *urange;
5052 struct f2fs_gc_range range;
5053 int err;
5054
5055 urange = compat_ptr(arg);
5056 err = get_user(range.sync, &urange->sync);
5057 err |= get_user(range.start, &urange->start);
5058 err |= get_user(range.len, &urange->len);
5059 if (err)
5060 return -EFAULT;
5061
5062 return __f2fs_ioc_gc_range(file, &range);
5063 }
5064
5065 struct compat_f2fs_move_range {
5066 u32 dst_fd;
5067 compat_u64 pos_in;
5068 compat_u64 pos_out;
5069 compat_u64 len;
5070 };
5071 #define F2FS_IOC32_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
5072 struct compat_f2fs_move_range)
5073
f2fs_compat_ioc_move_range(struct file * file,unsigned long arg)5074 static int f2fs_compat_ioc_move_range(struct file *file, unsigned long arg)
5075 {
5076 struct compat_f2fs_move_range __user *urange;
5077 struct f2fs_move_range range;
5078 int err;
5079
5080 urange = compat_ptr(arg);
5081 err = get_user(range.dst_fd, &urange->dst_fd);
5082 err |= get_user(range.pos_in, &urange->pos_in);
5083 err |= get_user(range.pos_out, &urange->pos_out);
5084 err |= get_user(range.len, &urange->len);
5085 if (err)
5086 return -EFAULT;
5087
5088 return __f2fs_ioc_move_range(file, &range);
5089 }
5090
f2fs_compat_ioctl(struct file * file,unsigned int cmd,unsigned long arg)5091 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5092 {
5093 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
5094 return -EIO;
5095 if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(file))))
5096 return -ENOSPC;
5097
5098 switch (cmd) {
5099 case FS_IOC32_GETVERSION:
5100 cmd = FS_IOC_GETVERSION;
5101 break;
5102 case F2FS_IOC32_GARBAGE_COLLECT_RANGE:
5103 return f2fs_compat_ioc_gc_range(file, arg);
5104 case F2FS_IOC32_MOVE_RANGE:
5105 return f2fs_compat_ioc_move_range(file, arg);
5106 case F2FS_IOC_START_ATOMIC_WRITE:
5107 case F2FS_IOC_START_ATOMIC_REPLACE:
5108 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
5109 case F2FS_IOC_START_VOLATILE_WRITE:
5110 case F2FS_IOC_RELEASE_VOLATILE_WRITE:
5111 case F2FS_IOC_ABORT_ATOMIC_WRITE:
5112 case F2FS_IOC_SHUTDOWN:
5113 case FITRIM:
5114 case FS_IOC_SET_ENCRYPTION_POLICY:
5115 case FS_IOC_GET_ENCRYPTION_PWSALT:
5116 case FS_IOC_GET_ENCRYPTION_POLICY:
5117 case FS_IOC_GET_ENCRYPTION_POLICY_EX:
5118 case FS_IOC_ADD_ENCRYPTION_KEY:
5119 case FS_IOC_REMOVE_ENCRYPTION_KEY:
5120 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
5121 case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
5122 case FS_IOC_GET_ENCRYPTION_NONCE:
5123 case F2FS_IOC_GARBAGE_COLLECT:
5124 case F2FS_IOC_WRITE_CHECKPOINT:
5125 case F2FS_IOC_DEFRAGMENT:
5126 case F2FS_IOC_FLUSH_DEVICE:
5127 case F2FS_IOC_GET_FEATURES:
5128 case F2FS_IOC_GET_PIN_FILE:
5129 case F2FS_IOC_SET_PIN_FILE:
5130 case F2FS_IOC_PRECACHE_EXTENTS:
5131 case F2FS_IOC_RESIZE_FS:
5132 case FS_IOC_ENABLE_VERITY:
5133 case FS_IOC_MEASURE_VERITY:
5134 case FS_IOC_READ_VERITY_METADATA:
5135 case FS_IOC_GETFSLABEL:
5136 case FS_IOC_SETFSLABEL:
5137 case F2FS_IOC_GET_COMPRESS_BLOCKS:
5138 case F2FS_IOC_RELEASE_COMPRESS_BLOCKS:
5139 case F2FS_IOC_RESERVE_COMPRESS_BLOCKS:
5140 case F2FS_IOC_SEC_TRIM_FILE:
5141 case F2FS_IOC_GET_COMPRESS_OPTION:
5142 case F2FS_IOC_SET_COMPRESS_OPTION:
5143 case F2FS_IOC_DECOMPRESS_FILE:
5144 case F2FS_IOC_COMPRESS_FILE:
5145 break;
5146 default:
5147 return -ENOIOCTLCMD;
5148 }
5149 return __f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
5150 }
5151 #endif
5152
5153 const struct file_operations f2fs_file_operations = {
5154 .llseek = f2fs_llseek,
5155 .read_iter = f2fs_file_read_iter,
5156 .write_iter = f2fs_file_write_iter,
5157 .iopoll = iocb_bio_iopoll,
5158 .open = f2fs_file_open,
5159 .release = f2fs_release_file,
5160 .mmap = f2fs_file_mmap,
5161 .flush = f2fs_file_flush,
5162 .fsync = f2fs_sync_file,
5163 .fallocate = f2fs_fallocate,
5164 .unlocked_ioctl = f2fs_ioctl,
5165 #ifdef CONFIG_COMPAT
5166 .compat_ioctl = f2fs_compat_ioctl,
5167 #endif
5168 .splice_read = f2fs_file_splice_read,
5169 .splice_write = iter_file_splice_write,
5170 .fadvise = f2fs_file_fadvise,
5171 .fop_flags = FOP_BUFFER_RASYNC,
5172 };
5173