projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
f2fs: support fault_type mount option
[linux-block.git] / fs / f2fs / file.c
CommitLineData
0a8165d7 1/*
fbfa2cc5
JK		 2 * fs/f2fs/file.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#include <linux/fs.h>
12#include <linux/f2fs_fs.h>
13#include <linux/stat.h>
14#include <linux/buffer_head.h>
15#include <linux/writeback.h>
ae51fb31 16#include <linux/blkdev.h>
fbfa2cc5
JK		 17#include <linux/falloc.h>
18#include <linux/types.h>
e9750824 19#include <linux/compat.h>
fbfa2cc5
JK		 20#include <linux/uaccess.h>
21#include <linux/mount.h>
7f7670fe 22#include <linux/pagevec.h>
dc91de78 23#include <linux/uio.h>
8da4b8c4 24#include <linux/uuid.h>
4dd6f977 25#include <linux/file.h>
fbfa2cc5
JK		 26
27#include "f2fs.h"
28#include "node.h"
29#include "segment.h"
30#include "xattr.h"
31#include "acl.h"
c1c1b583 32#include "gc.h"
db9f7c1a 33#include "trace.h"
a2a4a7e4 34#include <trace/events/f2fs.h>
fbfa2cc5 35
ea4d479b 36static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
5a3a2d83
QS		 37{
38 struct inode *inode = file_inode(vmf->vma->vm_file);
ea4d479b 39 vm_fault_t ret;
5a3a2d83
QS		 40
41 down_read(&F2FS_I(inode)->i_mmap_sem);
ea4d479b 42 ret = filemap_fault(vmf);
5a3a2d83
QS		 43 up_read(&F2FS_I(inode)->i_mmap_sem);
44
ea4d479b 45 return ret;
5a3a2d83
QS		 46}
47
ea4d479b 48static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
fbfa2cc5
JK		 49{
50 struct page *page = vmf->page;
11bac800 51 struct inode *inode = file_inode(vmf->vma->vm_file);
4081363f 52 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
fbfa2cc5 53 struct dnode_of_data dn;
e479556b 54 int err;
fbfa2cc5 55
1f227a3e
JK		 56 if (unlikely(f2fs_cp_error(sbi))) {
57 err = -EIO;
58 goto err;
59 }
60
fbfa2cc5 61 sb_start_pagefault(inode->i_sb);
b3d208f9
JK		 62
63 f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
b067ba1f 64
fbfa2cc5 65 /* block allocation */
e479556b 66 f2fs_lock_op(sbi);
b3d208f9 67 set_new_dnode(&dn, inode, NULL, NULL, 0);
b600965c 68 err = f2fs_reserve_block(&dn, page->index);
9ba69cf9
JK		 69 if (err) {
70 f2fs_unlock_op(sbi);
b600965c 71 goto out;
9ba69cf9
JK		 72 }
73 f2fs_put_dnode(&dn);
74 f2fs_unlock_op(sbi);
fbfa2cc5 75
2c4db1a6 76 f2fs_balance_fs(sbi, dn.node_changed);
2a340760 77
11bac800 78 file_update_time(vmf->vma->vm_file);
5a3a2d83 79 down_read(&F2FS_I(inode)->i_mmap_sem);
fbfa2cc5 80 lock_page(page);
6bacf52f 81 if (unlikely(page->mapping != inode->i_mapping ||
9851e6e1 82 page_offset(page) > i_size_read(inode) ||
6bacf52f 83 !PageUptodate(page))) {
fbfa2cc5
JK		 84 unlock_page(page);
85 err = -EFAULT;
5a3a2d83 86 goto out_sem;
fbfa2cc5
JK		 87 }
88
89 /*
90 * check to see if the page is mapped already (no holes)
91 */
92 if (PageMappedToDisk(page))
9851e6e1 93 goto mapped;
fbfa2cc5
JK		 94
95 /* page is wholly or partially inside EOF */
09cbfeaf 96 if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
9edcdabf 97 i_size_read(inode)) {
193bea1d 98 loff_t offset;
f11e98bd 99
09cbfeaf
KS		 100 offset = i_size_read(inode) & ~PAGE_MASK;
101 zero_user_segment(page, offset, PAGE_SIZE);
fbfa2cc5
JK		 102 }
103 set_page_dirty(page);
237c0790
JK		 104 if (!PageUptodate(page))
105 SetPageUptodate(page);
fbfa2cc5 106
b0af6d49
CY		 107 f2fs_update_iostat(sbi, APP_MAPPED_IO, F2FS_BLKSIZE);
108
e943a10d 109 trace_f2fs_vm_page_mkwrite(page, DATA);
9851e6e1
NJ		 110mapped:
111 /* fill the page */
fec1d657 112 f2fs_wait_on_page_writeback(page, DATA, false);
08b39fbd 113
6dbb1796
EB		 114 /* wait for GCed page writeback via META_MAPPING */
115 if (f2fs_post_read_required(inode))
d4c759ee 116 f2fs_wait_on_block_writeback(sbi, dn.data_blkaddr);
08b39fbd 117
5a3a2d83
QS		 118out_sem:
119 up_read(&F2FS_I(inode)->i_mmap_sem);
fbfa2cc5
JK		 120out:
121 sb_end_pagefault(inode->i_sb);
d0239e1b 122 f2fs_update_time(sbi, REQ_TIME);
1f227a3e 123err:
fbfa2cc5
JK		 124 return block_page_mkwrite_return(err);
125}
126
127static const struct vm_operations_struct f2fs_file_vm_ops = {
5a3a2d83 128 .fault = f2fs_filemap_fault,
f1820361 129 .map_pages = filemap_map_pages,
692bb55d 130 .page_mkwrite = f2fs_vm_page_mkwrite,
fbfa2cc5
JK		 131};
132
354a3399
JK		 133static int get_parent_ino(struct inode *inode, nid_t *pino)
134{
135 struct dentry *dentry;
136
137 inode = igrab(inode);
138 dentry = d_find_any_alias(inode);
139 iput(inode);
140 if (!dentry)
141 return 0;
142
f0947e5c
JK		 143 *pino = parent_ino(dentry);
144 dput(dentry);
354a3399
JK		 145 return 1;
146}
147
a5fd5050 148static inline enum cp_reason_type need_do_checkpoint(struct inode *inode)
9d1589ef 149{
4081363f 150 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
a5fd5050 151 enum cp_reason_type cp_reason = CP_NO_NEEDED;
9d1589ef 152
a5fd5050
CY		 153 if (!S_ISREG(inode->i_mode))
154 cp_reason = CP_NON_REGULAR;
155 else if (inode->i_nlink != 1)
156 cp_reason = CP_HARDLINK;
bbf156f7 157 else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
a5fd5050 158 cp_reason = CP_SB_NEED_CP;
9d1589ef 159 else if (file_wrong_pino(inode))
a5fd5050 160 cp_reason = CP_WRONG_PINO;
4d57b86d 161 else if (!f2fs_space_for_roll_forward(sbi))
a5fd5050 162 cp_reason = CP_NO_SPC_ROLL;
4d57b86d 163 else if (!f2fs_is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
a5fd5050 164 cp_reason = CP_NODE_NEED_CP;
d5053a34 165 else if (test_opt(sbi, FASTBOOT))
a5fd5050 166 cp_reason = CP_FASTBOOT_MODE;
63189b78 167 else if (F2FS_OPTION(sbi).active_logs == 2)
a5fd5050 168 cp_reason = CP_SPEC_LOG_NUM;
63189b78 169 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT &&
4d57b86d
CY		 170 f2fs_need_dentry_mark(sbi, inode->i_ino) &&
171 f2fs_exist_written_data(sbi, F2FS_I(inode)->i_pino,
172 TRANS_DIR_INO))
0a007b97 173 cp_reason = CP_RECOVER_DIR;
9d1589ef 174
a5fd5050 175 return cp_reason;
9d1589ef
CY		 176}
177
9c7bb702
CL		 178static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
179{
180 struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
181 bool ret = false;
182 /* But we need to avoid that there are some inode updates */
4d57b86d 183 if ((i && PageDirty(i)) || f2fs_need_inode_block_update(sbi, ino))
9c7bb702
CL		 184 ret = true;
185 f2fs_put_page(i, 0);
186 return ret;
187}
188
51455b19
CL		 189static void try_to_fix_pino(struct inode *inode)
190{
191 struct f2fs_inode_info *fi = F2FS_I(inode);
192 nid_t pino;
193
194 down_write(&fi->i_sem);
51455b19
CL		 195 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
196 get_parent_ino(inode, &pino)) {
205b9822 197 f2fs_i_pino_write(inode, pino);
51455b19 198 file_got_pino(inode);
51455b19 199 }
ee6d182f 200 up_write(&fi->i_sem);
51455b19
CL		 201}
202
608514de
JK		 203static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
204 int datasync, bool atomic)
fbfa2cc5
JK		 205{
206 struct inode *inode = file->f_mapping->host;
4081363f 207 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2403c155 208 nid_t ino = inode->i_ino;
fbfa2cc5 209 int ret = 0;
a5fd5050 210 enum cp_reason_type cp_reason = 0;
fbfa2cc5 211 struct writeback_control wbc = {
c81bf1c8 212 .sync_mode = WB_SYNC_ALL,
fbfa2cc5
JK		 213 .nr_to_write = LONG_MAX,
214 .for_reclaim = 0,
215 };
50fa53ec 216 unsigned int seq_id = 0;
fbfa2cc5 217
6bacf52f 218 if (unlikely(f2fs_readonly(inode->i_sb)))
1fa95b0b
NJ		 219 return 0;
220
a2a4a7e4 221 trace_f2fs_sync_file_enter(inode);
ea1aa12c
JK		 222
223 /* if fdatasync is triggered, let's do in-place-update */
c46a155b 224 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
91942321 225 set_inode_flag(inode, FI_NEED_IPU);
3b49c9a1 226 ret = file_write_and_wait_range(file, start, end);
91942321 227 clear_inode_flag(inode, FI_NEED_IPU);
c1ce1b02 228
a2a4a7e4 229 if (ret) {
a5fd5050 230 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
fbfa2cc5 231 return ret;
a2a4a7e4 232 }
fbfa2cc5 233
9c7bb702 234 /* if the inode is dirty, let's recover all the time */
281518c6 235 if (!f2fs_skip_inode_update(inode, datasync)) {
2286c020 236 f2fs_write_inode(inode, NULL);
9c7bb702
CL		 237 goto go_write;
238 }
239
6d99ba41
JK		 240 /*
241 * if there is no written data, don't waste time to write recovery info.
242 */
91942321 243 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
4d57b86d 244 !f2fs_exist_written_data(sbi, ino, APPEND_INO)) {
19c9c466 245
9c7bb702
CL		 246 /* it may call write_inode just prior to fsync */
247 if (need_inode_page_update(sbi, ino))
19c9c466 248 goto go_write;
19c9c466 249
91942321 250 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
4d57b86d 251 f2fs_exist_written_data(sbi, ino, UPDATE_INO))
6d99ba41
JK		 252 goto flush_out;
253 goto out;
254 }
19c9c466 255go_write:
e5d2385e
JK		 256 /*
257 * Both of fdatasync() and fsync() are able to be recovered from
258 * sudden-power-off.
259 */
91942321 260 down_read(&F2FS_I(inode)->i_sem);
a5fd5050 261 cp_reason = need_do_checkpoint(inode);
91942321 262 up_read(&F2FS_I(inode)->i_sem);
d928bfbf 263
a5fd5050 264 if (cp_reason) {
fbfa2cc5
JK		 265 /* all the dirty node pages should be flushed for POR */
266 ret = f2fs_sync_fs(inode->i_sb, 1);
d928bfbf 267
51455b19
CL		 268 /*
269 * We've secured consistency through sync_fs. Following pino
270 * will be used only for fsynced inodes after checkpoint.
271 */
272 try_to_fix_pino(inode);
91942321
JK		 273 clear_inode_flag(inode, FI_APPEND_WRITE);
274 clear_inode_flag(inode, FI_UPDATE_WRITE);
51455b19
CL		 275 goto out;
276 }
88bd02c9 277sync_nodes:
c29fd0c0 278 atomic_inc(&sbi->wb_sync_req[NODE]);
50fa53ec 279 ret = f2fs_fsync_node_pages(sbi, inode, &wbc, atomic, &seq_id);
c29fd0c0 280 atomic_dec(&sbi->wb_sync_req[NODE]);
c267ec15
JK		 281 if (ret)
282 goto out;
51455b19 283
871f599f 284 /* if cp_error was enabled, we should avoid infinite loop */
6d5a1495
CY		 285 if (unlikely(f2fs_cp_error(sbi))) {
286 ret = -EIO;
871f599f 287 goto out;
6d5a1495 288 }
871f599f 289
4d57b86d 290 if (f2fs_need_inode_block_update(sbi, ino)) {
7c45729a 291 f2fs_mark_inode_dirty_sync(inode, true);
51455b19
CL		 292 f2fs_write_inode(inode, NULL);
293 goto sync_nodes;
fbfa2cc5 294 }
51455b19 295
b6a245eb
JK		 296 /*
297 * If it's atomic_write, it's just fine to keep write ordering. So
298 * here we don't need to wait for node write completion, since we use
299 * node chain which serializes node blocks. If one of node writes are
300 * reordered, we can see simply broken chain, resulting in stopping
301 * roll-forward recovery. It means we'll recover all or none node blocks
302 * given fsync mark.
303 */
304 if (!atomic) {
50fa53ec 305 ret = f2fs_wait_on_node_pages_writeback(sbi, seq_id);
b6a245eb
JK		 306 if (ret)
307 goto out;
308 }
51455b19
CL		 309
310 /* once recovery info is written, don't need to tack this */
4d57b86d 311 f2fs_remove_ino_entry(sbi, ino, APPEND_INO);
91942321 312 clear_inode_flag(inode, FI_APPEND_WRITE);
51455b19 313flush_out:
d6290814 314 if (!atomic && F2FS_OPTION(sbi).fsync_mode != FSYNC_MODE_NOBARRIER)
39d787be 315 ret = f2fs_issue_flush(sbi, inode->i_ino);
3f06252f 316 if (!ret) {
4d57b86d 317 f2fs_remove_ino_entry(sbi, ino, UPDATE_INO);
3f06252f 318 clear_inode_flag(inode, FI_UPDATE_WRITE);
4d57b86d 319 f2fs_remove_ino_entry(sbi, ino, FLUSH_INO);
3f06252f 320 }
d0239e1b 321 f2fs_update_time(sbi, REQ_TIME);
fbfa2cc5 322out:
a5fd5050 323 trace_f2fs_sync_file_exit(inode, cp_reason, datasync, ret);
05ca3632 324 f2fs_trace_ios(NULL, 1);
fbfa2cc5
JK		 325 return ret;
326}
327
608514de
JK		 328int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
329{
1f227a3e
JK		 330 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(file)))))
331 return -EIO;
608514de
JK		 332 return f2fs_do_sync_file(file, start, end, datasync, false);
333}
334
7f7670fe
JK		 335static pgoff_t __get_first_dirty_index(struct address_space *mapping,
336 pgoff_t pgofs, int whence)
337{
8faab642 338 struct page *page;
7f7670fe
JK		 339 int nr_pages;
340
341 if (whence != SEEK_DATA)
342 return 0;
343
344 /* find first dirty page index */
8faab642
JK		 345 nr_pages = find_get_pages_tag(mapping, &pgofs, PAGECACHE_TAG_DIRTY,
346 1, &page);
347 if (!nr_pages)
348 return ULONG_MAX;
349 pgofs = page->index;
350 put_page(page);
7f7670fe
JK		 351 return pgofs;
352}
353
e1da7872
CY		 354static bool __found_offset(struct f2fs_sb_info *sbi, block_t blkaddr,
355 pgoff_t dirty, pgoff_t pgofs, int whence)
7f7670fe
JK		 356{
357 switch (whence) {
358 case SEEK_DATA:
359 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
e1da7872 360 is_valid_data_blkaddr(sbi, blkaddr))
7f7670fe
JK		 361 return true;
362 break;
363 case SEEK_HOLE:
364 if (blkaddr == NULL_ADDR)
365 return true;
366 break;
367 }
368 return false;
369}
370
267378d4
CY		 371static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
372{
373 struct inode *inode = file->f_mapping->host;
374 loff_t maxbytes = inode->i_sb->s_maxbytes;
375 struct dnode_of_data dn;
7f7670fe
JK		 376 pgoff_t pgofs, end_offset, dirty;
377 loff_t data_ofs = offset;
378 loff_t isize;
267378d4
CY		 379 int err = 0;
380
5955102c 381 inode_lock(inode);
267378d4
CY		 382
383 isize = i_size_read(inode);
384 if (offset >= isize)
385 goto fail;
386
387 /* handle inline data case */
622f28ae 388 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
267378d4
CY		 389 if (whence == SEEK_HOLE)
390 data_ofs = isize;
391 goto found;
392 }
393
09cbfeaf 394 pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
267378d4 395
7f7670fe
JK		 396 dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
397
09cbfeaf 398 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
267378d4 399 set_new_dnode(&dn, inode, NULL, NULL, 0);
4d57b86d 400 err = f2fs_get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
267378d4
CY		 401 if (err && err != -ENOENT) {
402 goto fail;
403 } else if (err == -ENOENT) {
e1c42045 404 /* direct node does not exists */
267378d4 405 if (whence == SEEK_DATA) {
4d57b86d 406 pgofs = f2fs_get_next_page_offset(&dn, pgofs);
267378d4
CY		 407 continue;
408 } else {
409 goto found;
410 }
411 }
412
81ca7350 413 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
267378d4
CY		 414
415 /* find data/hole in dnode block */
416 for (; dn.ofs_in_node < end_offset;
417 dn.ofs_in_node++, pgofs++,
09cbfeaf 418 data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
267378d4 419 block_t blkaddr;
f11e98bd 420
7a2af766
CY		 421 blkaddr = datablock_addr(dn.inode,
422 dn.node_page, dn.ofs_in_node);
267378d4 423
c9b60788
CY		 424 if (__is_valid_data_blkaddr(blkaddr) &&
425 !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
426 blkaddr, DATA_GENERIC)) {
427 f2fs_put_dnode(&dn);
428 goto fail;
429 }
430
e1da7872
CY		 431 if (__found_offset(F2FS_I_SB(inode), blkaddr, dirty,
432 pgofs, whence)) {
267378d4
CY		 433 f2fs_put_dnode(&dn);
434 goto found;
435 }
436 }
437 f2fs_put_dnode(&dn);
438 }
439
440 if (whence == SEEK_DATA)
441 goto fail;
267378d4 442found:
fe369bc8
JK		 443 if (whence == SEEK_HOLE && data_ofs > isize)
444 data_ofs = isize;
5955102c 445 inode_unlock(inode);
267378d4
CY		 446 return vfs_setpos(file, data_ofs, maxbytes);
447fail:
5955102c 448 inode_unlock(inode);
267378d4
CY		 449 return -ENXIO;
450}
451
452static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
453{
454 struct inode *inode = file->f_mapping->host;
455 loff_t maxbytes = inode->i_sb->s_maxbytes;
456
457 switch (whence) {
458 case SEEK_SET:
459 case SEEK_CUR:
460 case SEEK_END:
461 return generic_file_llseek_size(file, offset, whence,
462 maxbytes, i_size_read(inode));
463 case SEEK_DATA:
464 case SEEK_HOLE:
0b4c5afd
JK		 465 if (offset < 0)
466 return -ENXIO;
267378d4
CY		 467 return f2fs_seek_block(file, offset, whence);
468 }
469
470 return -EINVAL;
471}
472
fbfa2cc5
JK		 473static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
474{
b3d208f9 475 struct inode *inode = file_inode(file);
b9d777b8 476 int err;
b3d208f9 477
1f227a3e
JK		 478 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
479 return -EIO;
480
b3d208f9 481 /* we don't need to use inline_data strictly */
b9d777b8
JK		 482 err = f2fs_convert_inline_inode(inode);
483 if (err)
484 return err;
b3d208f9 485
fbfa2cc5
JK		 486 file_accessed(file);
487 vma->vm_ops = &f2fs_file_vm_ops;
488 return 0;
489}
490
fcc85a4d
JK		 491static int f2fs_file_open(struct inode *inode, struct file *filp)
492{
2e168c82 493 int err = fscrypt_file_open(inode, filp);
fcc85a4d 494
2e168c82
EB		 495 if (err)
496 return err;
b91050a8
HL		 497
498 filp->f_mode |= FMODE_NOWAIT;
499
0abd675e 500 return dquot_file_open(inode, filp);
fcc85a4d
JK		 501}
502
4d57b86d 503void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
fbfa2cc5 504{
4081363f 505 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
fbfa2cc5 506 struct f2fs_node *raw_node;
19b2c30d 507 int nr_free = 0, ofs = dn->ofs_in_node, len = count;
fbfa2cc5 508 __le32 *addr;
7a2af766
CY		 509 int base = 0;
510
511 if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
512 base = get_extra_isize(dn->inode);
fbfa2cc5 513
45590710 514 raw_node = F2FS_NODE(dn->node_page);
7a2af766 515 addr = blkaddr_in_node(raw_node) + base + ofs;
fbfa2cc5 516
6c311ec6 517 for (; count > 0; count--, addr++, dn->ofs_in_node++) {
fbfa2cc5 518 block_t blkaddr = le32_to_cpu(*addr);
f11e98bd 519
fbfa2cc5
JK		 520 if (blkaddr == NULL_ADDR)
521 continue;
522
e1509cf2 523 dn->data_blkaddr = NULL_ADDR;
4d57b86d 524 f2fs_set_data_blkaddr(dn);
c9b60788
CY		 525
526 if (__is_valid_data_blkaddr(blkaddr) &&
527 !f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC))
528 continue;
529
4d57b86d 530 f2fs_invalidate_blocks(sbi, blkaddr);
3c6c2beb 531 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
91942321 532 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
fbfa2cc5
JK		 533 nr_free++;
534 }
19b2c30d 535
fbfa2cc5 536 if (nr_free) {
19b2c30d
CY		 537 pgoff_t fofs;
538 /*
539 * once we invalidate valid blkaddr in range [ofs, ofs + count],
540 * we will invalidate all blkaddr in the whole range.
541 */
4d57b86d 542 fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page),
81ca7350 543 dn->inode) + ofs;
19b2c30d 544 f2fs_update_extent_cache_range(dn, fofs, 0, len);
d7cc950b 545 dec_valid_block_count(sbi, dn->inode, nr_free);
fbfa2cc5
JK		 546 }
547 dn->ofs_in_node = ofs;
51dd6249 548
d0239e1b 549 f2fs_update_time(sbi, REQ_TIME);
51dd6249
NJ		 550 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
551 dn->ofs_in_node, nr_free);
fbfa2cc5
JK		 552}
553
4d57b86d 554void f2fs_truncate_data_blocks(struct dnode_of_data *dn)
fbfa2cc5 555{
4d57b86d 556 f2fs_truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
fbfa2cc5
JK		 557}
558
0bfcfcca 559static int truncate_partial_data_page(struct inode *inode, u64 from,
43f3eae1 560 bool cache_only)
fbfa2cc5 561{
193bea1d 562 loff_t offset = from & (PAGE_SIZE - 1);
09cbfeaf 563 pgoff_t index = from >> PAGE_SHIFT;
43f3eae1 564 struct address_space *mapping = inode->i_mapping;
fbfa2cc5
JK		 565 struct page *page;
566
43f3eae1 567 if (!offset && !cache_only)
b3d208f9 568 return 0;
fbfa2cc5 569
43f3eae1 570 if (cache_only) {
34b5d5c2 571 page = find_lock_page(mapping, index);
43f3eae1
JK		 572 if (page && PageUptodate(page))
573 goto truncate_out;
574 f2fs_put_page(page, 1);
b3d208f9 575 return 0;
43f3eae1 576 }
fbfa2cc5 577
4d57b86d 578 page = f2fs_get_lock_data_page(inode, index, true);
43f3eae1 579 if (IS_ERR(page))
a78aaa2c 580 return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
43f3eae1 581truncate_out:
fec1d657 582 f2fs_wait_on_page_writeback(page, DATA, true);
09cbfeaf 583 zero_user(page, offset, PAGE_SIZE - offset);
a9bcf9bc
JK		 584
585 /* An encrypted inode should have a key and truncate the last page. */
586 f2fs_bug_on(F2FS_I_SB(inode), cache_only && f2fs_encrypted_inode(inode));
587 if (!cache_only)
0bfcfcca 588 set_page_dirty(page);
fbfa2cc5 589 f2fs_put_page(page, 1);
b3d208f9 590 return 0;
fbfa2cc5
JK		 591}
592
4d57b86d 593int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)
fbfa2cc5 594{
4081363f 595 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
fbfa2cc5
JK		 596 struct dnode_of_data dn;
597 pgoff_t free_from;
9ffe0fb5 598 int count = 0, err = 0;
b3d208f9 599 struct page *ipage;
0bfcfcca 600 bool truncate_page = false;
fbfa2cc5 601
51dd6249
NJ		 602 trace_f2fs_truncate_blocks_enter(inode, from);
603
df033caf 604 free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
fbfa2cc5 605
09210c97
CY		 606 if (free_from >= sbi->max_file_blocks)
607 goto free_partial;
608
764aa3e9
JK		 609 if (lock)
610 f2fs_lock_op(sbi);
9ffe0fb5 611
4d57b86d 612 ipage = f2fs_get_node_page(sbi, inode->i_ino);
b3d208f9
JK		 613 if (IS_ERR(ipage)) {
614 err = PTR_ERR(ipage);
615 goto out;
616 }
617
618 if (f2fs_has_inline_data(inode)) {
4d57b86d 619 f2fs_truncate_inline_inode(inode, ipage, from);
b3d208f9 620 f2fs_put_page(ipage, 1);
0bfcfcca 621 truncate_page = true;
b3d208f9
JK		 622 goto out;
623 }
624
625 set_new_dnode(&dn, inode, ipage, NULL, 0);
4d57b86d 626 err = f2fs_get_dnode_of_data(&dn, free_from, LOOKUP_NODE_RA);
fbfa2cc5
JK		 627 if (err) {
628 if (err == -ENOENT)
629 goto free_next;
b3d208f9 630 goto out;
1ce86bf6
JK		 631 }
632
81ca7350 633 count = ADDRS_PER_PAGE(dn.node_page, inode);
fbfa2cc5
JK		 634
635 count -= dn.ofs_in_node;
9850cf4a 636 f2fs_bug_on(sbi, count < 0);
39936837 637
fbfa2cc5 638 if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
4d57b86d 639 f2fs_truncate_data_blocks_range(&dn, count);
fbfa2cc5
JK		 640 free_from += count;
641 }
642
643 f2fs_put_dnode(&dn);
644free_next:
4d57b86d 645 err = f2fs_truncate_inode_blocks(inode, free_from);
764d2c80
JK		 646out:
647 if (lock)
648 f2fs_unlock_op(sbi);
09210c97 649free_partial:
b3d208f9
JK		 650 /* lastly zero out the first data page */
651 if (!err)
0bfcfcca 652 err = truncate_partial_data_page(inode, from, truncate_page);
fbfa2cc5 653
51dd6249 654 trace_f2fs_truncate_blocks_exit(inode, err);
fbfa2cc5
JK		 655 return err;
656}
657
9a449e9c 658int f2fs_truncate(struct inode *inode)
fbfa2cc5 659{
b0154891
CY		 660 int err;
661
1f227a3e
JK		 662 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
663 return -EIO;
664
fbfa2cc5
JK		 665 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
666 S_ISLNK(inode->i_mode)))
b0154891 667 return 0;
fbfa2cc5 668
51dd6249
NJ		 669 trace_f2fs_truncate(inode);
670
14b44d23
JK		 671#ifdef CONFIG_F2FS_FAULT_INJECTION
672 if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
673 f2fs_show_injection_info(FAULT_TRUNCATE);
674 return -EIO;
675 }
676#endif
92dffd01 677 /* we should check inline_data size */
b9d777b8 678 if (!f2fs_may_inline_data(inode)) {
b0154891
CY		 679 err = f2fs_convert_inline_inode(inode);
680 if (err)
681 return err;
92dffd01
JK		 682 }
683
4d57b86d 684 err = f2fs_truncate_blocks(inode, i_size_read(inode), true);
b0154891
CY		 685 if (err)
686 return err;
687
078cd827 688 inode->i_mtime = inode->i_ctime = current_time(inode);
7c45729a 689 f2fs_mark_inode_dirty_sync(inode, false);
b0154891 690 return 0;
fbfa2cc5
JK		 691}
692
a528d35e 693int f2fs_getattr(const struct path *path, struct kstat *stat,
1c6d8ee4 694 u32 request_mask, unsigned int query_flags)
fbfa2cc5 695{
a528d35e 696 struct inode *inode = d_inode(path->dentry);
1c6d8ee4 697 struct f2fs_inode_info *fi = F2FS_I(inode);
1c1d35df 698 struct f2fs_inode *ri;
1c6d8ee4
CY		 699 unsigned int flags;
700
1c1d35df
CY		 701 if (f2fs_has_extra_attr(inode) &&
702 f2fs_sb_has_inode_crtime(inode->i_sb) &&
703 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
704 stat->result_mask |= STATX_BTIME;
705 stat->btime.tv_sec = fi->i_crtime.tv_sec;
706 stat->btime.tv_nsec = fi->i_crtime.tv_nsec;
707 }
708
c807a7cb 709 flags = fi->i_flags & F2FS_FL_USER_VISIBLE;
59c84408 710 if (flags & F2FS_APPEND_FL)
1c6d8ee4 711 stat->attributes |= STATX_ATTR_APPEND;
59c84408 712 if (flags & F2FS_COMPR_FL)
1c6d8ee4
CY		 713 stat->attributes |= STATX_ATTR_COMPRESSED;
714 if (f2fs_encrypted_inode(inode))
715 stat->attributes |= STATX_ATTR_ENCRYPTED;
59c84408 716 if (flags & F2FS_IMMUTABLE_FL)
1c6d8ee4 717 stat->attributes |= STATX_ATTR_IMMUTABLE;
59c84408 718 if (flags & F2FS_NODUMP_FL)
1c6d8ee4
CY		 719 stat->attributes |= STATX_ATTR_NODUMP;
720
721 stat->attributes_mask |= (STATX_ATTR_APPEND |
722 STATX_ATTR_COMPRESSED |
723 STATX_ATTR_ENCRYPTED |
724 STATX_ATTR_IMMUTABLE |
725 STATX_ATTR_NODUMP);
726
fbfa2cc5 727 generic_fillattr(inode, stat);
5b4267d1
JK		 728
729 /* we need to show initial sectors used for inline_data/dentries */
730 if ((S_ISREG(inode->i_mode) && f2fs_has_inline_data(inode)) ||
731 f2fs_has_inline_dentry(inode))
732 stat->blocks += (stat->size + 511) >> 9;
733
fbfa2cc5
JK		 734 return 0;
735}
736
737#ifdef CONFIG_F2FS_FS_POSIX_ACL
738static void __setattr_copy(struct inode *inode, const struct iattr *attr)
739{
fbfa2cc5
JK		 740 unsigned int ia_valid = attr->ia_valid;
741
742 if (ia_valid & ATTR_UID)
743 inode->i_uid = attr->ia_uid;
744 if (ia_valid & ATTR_GID)
745 inode->i_gid = attr->ia_gid;
746 if (ia_valid & ATTR_ATIME)
95582b00
DD		 747 inode->i_atime = timespec64_trunc(attr->ia_atime,
748 inode->i_sb->s_time_gran);
fbfa2cc5 749 if (ia_valid & ATTR_MTIME)
95582b00
DD		 750 inode->i_mtime = timespec64_trunc(attr->ia_mtime,
751 inode->i_sb->s_time_gran);
fbfa2cc5 752 if (ia_valid & ATTR_CTIME)
95582b00
DD		 753 inode->i_ctime = timespec64_trunc(attr->ia_ctime,
754 inode->i_sb->s_time_gran);
fbfa2cc5
JK		 755 if (ia_valid & ATTR_MODE) {
756 umode_t mode = attr->ia_mode;
757
758 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
759 mode &= ~S_ISGID;
91942321 760 set_acl_inode(inode, mode);
fbfa2cc5
JK		 761 }
762}
763#else
764#define __setattr_copy setattr_copy
765#endif
766
767int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
768{
2b0143b5 769 struct inode *inode = d_inode(dentry);
fbfa2cc5 770 int err;
c0ed4405 771 bool size_changed = false;
fbfa2cc5 772
1f227a3e
JK		 773 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
774 return -EIO;
775
31051c85 776 err = setattr_prepare(dentry, attr);
fbfa2cc5
JK		 777 if (err)
778 return err;
779
20bb2479
EB		 780 err = fscrypt_prepare_setattr(dentry, attr);
781 if (err)
782 return err;
783
0abd675e
CY		 784 if (is_quota_modification(inode, attr)) {
785 err = dquot_initialize(inode);
786 if (err)
787 return err;
788 }
789 if ((attr->ia_valid & ATTR_UID &&
790 !uid_eq(attr->ia_uid, inode->i_uid)) ||
791 (attr->ia_valid & ATTR_GID &&
792 !gid_eq(attr->ia_gid, inode->i_gid))) {
793 err = dquot_transfer(inode, attr);
794 if (err)
795 return err;
796 }
797
09db6a2e 798 if (attr->ia_valid & ATTR_SIZE) {
a33c1502
CY		 799 bool to_smaller = (attr->ia_size <= i_size_read(inode));
800
801 down_write(&F2FS_I(inode)->i_mmap_sem);
802 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
803
804 truncate_setsize(inode, attr->ia_size);
805
806 if (to_smaller)
9a449e9c 807 err = f2fs_truncate(inode);
a33c1502
CY		 808 /*
809 * do not trim all blocks after i_size if target size is
810 * larger than i_size.
811 */
812 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
813 up_write(&F2FS_I(inode)->i_mmap_sem);
814
815 if (err)
816 return err;
0cab80ee 817
a33c1502 818 if (!to_smaller) {
0cab80ee 819 /* should convert inline inode here */
b9d777b8 820 if (!f2fs_may_inline_data(inode)) {
0cab80ee
CY		 821 err = f2fs_convert_inline_inode(inode);
822 if (err)
823 return err;
824 }
078cd827 825 inode->i_mtime = inode->i_ctime = current_time(inode);
09db6a2e 826 }
c0ed4405 827
a0d00fad
CY		 828 down_write(&F2FS_I(inode)->i_sem);
829 F2FS_I(inode)->last_disk_size = i_size_read(inode);
830 up_write(&F2FS_I(inode)->i_sem);
831
c0ed4405 832 size_changed = true;
fbfa2cc5
JK		 833 }
834
835 __setattr_copy(inode, attr);
836
837 if (attr->ia_valid & ATTR_MODE) {
4d57b86d 838 err = posix_acl_chmod(inode, f2fs_get_inode_mode(inode));
91942321
JK		 839 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
840 inode->i_mode = F2FS_I(inode)->i_acl_mode;
841 clear_inode_flag(inode, FI_ACL_MODE);
fbfa2cc5
JK		 842 }
843 }
844
c0ed4405
YH		 845 /* file size may changed here */
846 f2fs_mark_inode_dirty_sync(inode, size_changed);
15d04354
JK		 847
848 /* inode change will produce dirty node pages flushed by checkpoint */
849 f2fs_balance_fs(F2FS_I_SB(inode), true);
850
fbfa2cc5
JK		 851 return err;
852}
853
854const struct inode_operations f2fs_file_inode_operations = {
855 .getattr = f2fs_getattr,
856 .setattr = f2fs_setattr,
857 .get_acl = f2fs_get_acl,
a6dda0e6 858 .set_acl = f2fs_set_acl,
fbfa2cc5 859#ifdef CONFIG_F2FS_FS_XATTR
fbfa2cc5 860 .listxattr = f2fs_listxattr,
fbfa2cc5 861#endif
9ab70134 862 .fiemap = f2fs_fiemap,
fbfa2cc5
JK		 863};
864
6394328a 865static int fill_zero(struct inode *inode, pgoff_t index,
fbfa2cc5
JK		 866 loff_t start, loff_t len)
867{
4081363f 868 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
fbfa2cc5
JK		 869 struct page *page;
870
871 if (!len)
6394328a 872 return 0;
fbfa2cc5 873
2c4db1a6 874 f2fs_balance_fs(sbi, true);
bd43df02 875
e479556b 876 f2fs_lock_op(sbi);
4d57b86d 877 page = f2fs_get_new_data_page(inode, NULL, index, false);
e479556b 878 f2fs_unlock_op(sbi);
fbfa2cc5 879
6394328a
CY		 880 if (IS_ERR(page))
881 return PTR_ERR(page);
882
fec1d657 883 f2fs_wait_on_page_writeback(page, DATA, true);
6394328a
CY		 884 zero_user(page, start, len);
885 set_page_dirty(page);
886 f2fs_put_page(page, 1);
887 return 0;
fbfa2cc5
JK		 888}
889
4d57b86d 890int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
fbfa2cc5 891{
fbfa2cc5
JK		 892 int err;
893
ea58711e 894 while (pg_start < pg_end) {
fbfa2cc5 895 struct dnode_of_data dn;
ea58711e 896 pgoff_t end_offset, count;
9eaeba70 897
fbfa2cc5 898 set_new_dnode(&dn, inode, NULL, NULL, 0);
4d57b86d 899 err = f2fs_get_dnode_of_data(&dn, pg_start, LOOKUP_NODE);
fbfa2cc5 900 if (err) {
ea58711e 901 if (err == -ENOENT) {
4d57b86d
CY		 902 pg_start = f2fs_get_next_page_offset(&dn,
903 pg_start);
fbfa2cc5 904 continue;
ea58711e 905 }
fbfa2cc5
JK		 906 return err;
907 }
908
81ca7350 909 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
ea58711e
CY		 910 count = min(end_offset - dn.ofs_in_node, pg_end - pg_start);
911
912 f2fs_bug_on(F2FS_I_SB(inode), count == 0 || count > end_offset);
913
4d57b86d 914 f2fs_truncate_data_blocks_range(&dn, count);
fbfa2cc5 915 f2fs_put_dnode(&dn);
ea58711e
CY		 916
917 pg_start += count;
fbfa2cc5
JK		 918 }
919 return 0;
920}
921
a66c7b2f 922static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
fbfa2cc5
JK		 923{
924 pgoff_t pg_start, pg_end;
925 loff_t off_start, off_end;
b9d777b8 926 int ret;
fbfa2cc5 927
b9d777b8
JK		 928 ret = f2fs_convert_inline_inode(inode);
929 if (ret)
930 return ret;
9ffe0fb5 931
09cbfeaf
KS		 932 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
933 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
fbfa2cc5 934
09cbfeaf
KS		 935 off_start = offset & (PAGE_SIZE - 1);
936 off_end = (offset + len) & (PAGE_SIZE - 1);
fbfa2cc5
JK		 937
938 if (pg_start == pg_end) {
6394328a 939 ret = fill_zero(inode, pg_start, off_start,
fbfa2cc5 940 off_end - off_start);
6394328a
CY		 941 if (ret)
942 return ret;
fbfa2cc5 943 } else {
6394328a
CY		 944 if (off_start) {
945 ret = fill_zero(inode, pg_start++, off_start,
09cbfeaf 946 PAGE_SIZE - off_start);
6394328a
CY		 947 if (ret)
948 return ret;
949 }
950 if (off_end) {
951 ret = fill_zero(inode, pg_end, 0, off_end);
952 if (ret)
953 return ret;
954 }
fbfa2cc5
JK		 955
956 if (pg_start < pg_end) {
957 struct address_space *mapping = inode->i_mapping;
958 loff_t blk_start, blk_end;
4081363f 959 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1127a3d4 960
2c4db1a6 961 f2fs_balance_fs(sbi, true);
fbfa2cc5 962
09cbfeaf
KS		 963 blk_start = (loff_t)pg_start << PAGE_SHIFT;
964 blk_end = (loff_t)pg_end << PAGE_SHIFT;
a33c1502 965
5a3a2d83 966 down_write(&F2FS_I(inode)->i_mmap_sem);
a33c1502
CY		 967 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
968
fbfa2cc5
JK		 969 truncate_inode_pages_range(mapping, blk_start,
970 blk_end - 1);
39936837 971
e479556b 972 f2fs_lock_op(sbi);
4d57b86d 973 ret = f2fs_truncate_hole(inode, pg_start, pg_end);
e479556b 974 f2fs_unlock_op(sbi);
a33c1502
CY		 975
976 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
5a3a2d83 977 up_write(&F2FS_I(inode)->i_mmap_sem);
fbfa2cc5
JK		 978 }
979 }
980
fbfa2cc5
JK		 981 return ret;
982}
983
0a2aa8fb
JK		 984static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
985 int *do_replace, pgoff_t off, pgoff_t len)
b4ace337
CY		 986{
987 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
988 struct dnode_of_data dn;
0a2aa8fb 989 int ret, done, i;
ecbaa406 990
0a2aa8fb 991next_dnode:
6e2c64ad 992 set_new_dnode(&dn, inode, NULL, NULL, 0);
4d57b86d 993 ret = f2fs_get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
6e2c64ad
JK		 994 if (ret && ret != -ENOENT) {
995 return ret;
996 } else if (ret == -ENOENT) {
0a2aa8fb
JK		 997 if (dn.max_level == 0)
998 return -ENOENT;
999 done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len);
1000 blkaddr += done;
1001 do_replace += done;
1002 goto next;
1003 }
1004
1005 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
1006 dn.ofs_in_node, len);
1007 for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
7a2af766
CY		 1008 *blkaddr = datablock_addr(dn.inode,
1009 dn.node_page, dn.ofs_in_node);
4d57b86d 1010 if (!f2fs_is_checkpointed_data(sbi, *blkaddr)) {
0a2aa8fb
JK		 1011
1012 if (test_opt(sbi, LFS)) {
1013 f2fs_put_dnode(&dn);
1014 return -ENOTSUPP;
1015 }
1016
6e2c64ad 1017 /* do not invalidate this block address */
f28b3434 1018 f2fs_update_data_blkaddr(&dn, NULL_ADDR);
0a2aa8fb 1019 *do_replace = 1;
b4ace337 1020 }
6e2c64ad 1021 }
0a2aa8fb
JK		 1022 f2fs_put_dnode(&dn);
1023next:
1024 len -= done;
1025 off += done;
1026 if (len)
1027 goto next_dnode;
1028 return 0;
1029}
b4ace337 1030
0a2aa8fb
JK		 1031static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
1032 int *do_replace, pgoff_t off, int len)
1033{
1034 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1035 struct dnode_of_data dn;
1036 int ret, i;
b4ace337 1037
0a2aa8fb
JK		 1038 for (i = 0; i < len; i++, do_replace++, blkaddr++) {
1039 if (*do_replace == 0)
1040 continue;
b4ace337 1041
0a2aa8fb 1042 set_new_dnode(&dn, inode, NULL, NULL, 0);
4d57b86d 1043 ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
0a2aa8fb
JK		 1044 if (ret) {
1045 dec_valid_block_count(sbi, inode, 1);
4d57b86d 1046 f2fs_invalidate_blocks(sbi, *blkaddr);
0a2aa8fb
JK		 1047 } else {
1048 f2fs_update_data_blkaddr(&dn, *blkaddr);
36abef4e 1049 }
0a2aa8fb
JK		 1050 f2fs_put_dnode(&dn);
1051 }
1052 return 0;
1053}
1054
1055static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
1056 block_t *blkaddr, int *do_replace,
1057 pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
1058{
1059 struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
1060 pgoff_t i = 0;
1061 int ret;
36abef4e 1062
0a2aa8fb
JK		 1063 while (i < len) {
1064 if (blkaddr[i] == NULL_ADDR && !full) {
1065 i++;
1066 continue;
6e2c64ad 1067 }
b4ace337 1068
0a2aa8fb
JK		 1069 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
1070 struct dnode_of_data dn;
1071 struct node_info ni;
1072 size_t new_size;
1073 pgoff_t ilen;
b4ace337 1074
0a2aa8fb 1075 set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
4d57b86d 1076 ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
0a2aa8fb
JK		 1077 if (ret)
1078 return ret;
b4ace337 1079
7735730d
CY		 1080 ret = f2fs_get_node_info(sbi, dn.nid, &ni);
1081 if (ret) {
1082 f2fs_put_dnode(&dn);
1083 return ret;
1084 }
1085
0a2aa8fb
JK		 1086 ilen = min((pgoff_t)
1087 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
1088 dn.ofs_in_node, len - i);
1089 do {
7a2af766
CY		 1090 dn.data_blkaddr = datablock_addr(dn.inode,
1091 dn.node_page, dn.ofs_in_node);
4d57b86d 1092 f2fs_truncate_data_blocks_range(&dn, 1);
0a2aa8fb
JK		 1093
1094 if (do_replace[i]) {
1095 f2fs_i_blocks_write(src_inode,
0abd675e 1096 1, false, false);
0a2aa8fb 1097 f2fs_i_blocks_write(dst_inode,
0abd675e 1098 1, true, false);
0a2aa8fb
JK		 1099 f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
1100 blkaddr[i], ni.version, true, false);
1101
1102 do_replace[i] = 0;
1103 }
1104 dn.ofs_in_node++;
1105 i++;
1106 new_size = (dst + i) << PAGE_SHIFT;
1107 if (dst_inode->i_size < new_size)
1108 f2fs_i_size_write(dst_inode, new_size);
e87f7329 1109 } while (--ilen && (do_replace[i] || blkaddr[i] == NULL_ADDR));
6e2c64ad 1110
0a2aa8fb
JK		 1111 f2fs_put_dnode(&dn);
1112 } else {
1113 struct page *psrc, *pdst;
1114
4d57b86d
CY		 1115 psrc = f2fs_get_lock_data_page(src_inode,
1116 src + i, true);
0a2aa8fb
JK		 1117 if (IS_ERR(psrc))
1118 return PTR_ERR(psrc);
4d57b86d 1119 pdst = f2fs_get_new_data_page(dst_inode, NULL, dst + i,
0a2aa8fb
JK		 1120 true);
1121 if (IS_ERR(pdst)) {
1122 f2fs_put_page(psrc, 1);
1123 return PTR_ERR(pdst);
1124 }
1125 f2fs_copy_page(psrc, pdst);
1126 set_page_dirty(pdst);
1127 f2fs_put_page(pdst, 1);
6e2c64ad 1128 f2fs_put_page(psrc, 1);
b4ace337 1129
4d57b86d
CY		 1130 ret = f2fs_truncate_hole(src_inode,
1131 src + i, src + i + 1);
0a2aa8fb
JK		 1132 if (ret)
1133 return ret;
1134 i++;
1135 }
6e2c64ad
JK		 1136 }
1137 return 0;
0a2aa8fb 1138}
b4ace337 1139
0a2aa8fb
JK		 1140static int __exchange_data_block(struct inode *src_inode,
1141 struct inode *dst_inode, pgoff_t src, pgoff_t dst,
363cad7f 1142 pgoff_t len, bool full)
0a2aa8fb
JK		 1143{
1144 block_t *src_blkaddr;
1145 int *do_replace;
363cad7f 1146 pgoff_t olen;
0a2aa8fb
JK		 1147 int ret;
1148
363cad7f
JK		 1149 while (len) {
1150 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
0a2aa8fb 1151
628b3d14 1152 src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
9d2a789c
KC		 1153 array_size(olen, sizeof(block_t)),
1154 GFP_KERNEL);
363cad7f
JK		 1155 if (!src_blkaddr)
1156 return -ENOMEM;
0a2aa8fb 1157
628b3d14 1158 do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode),
9d2a789c
KC		 1159 array_size(olen, sizeof(int)),
1160 GFP_KERNEL);
363cad7f
JK		 1161 if (!do_replace) {
1162 kvfree(src_blkaddr);
1163 return -ENOMEM;
1164 }
0a2aa8fb 1165
363cad7f
JK		 1166 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1167 do_replace, src, olen);
1168 if (ret)
1169 goto roll_back;
0a2aa8fb 1170
363cad7f
JK		 1171 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1172 do_replace, src, dst, olen, full);
1173 if (ret)
1174 goto roll_back;
1175
1176 src += olen;
1177 dst += olen;
1178 len -= olen;
1179
1180 kvfree(src_blkaddr);
1181 kvfree(do_replace);
1182 }
0a2aa8fb
JK		 1183 return 0;
1184
1185roll_back:
9fd62605 1186 __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, olen);
0a2aa8fb
JK		 1187 kvfree(src_blkaddr);
1188 kvfree(do_replace);
6e2c64ad
JK		 1189 return ret;
1190}
b4ace337 1191
6e2c64ad
JK		 1192static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
1193{
1194 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1195 pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
0a2aa8fb 1196 int ret;
6e2c64ad 1197
0a2aa8fb
JK		 1198 f2fs_balance_fs(sbi, true);
1199 f2fs_lock_op(sbi);
5f281fab
JK		 1200
1201 f2fs_drop_extent_tree(inode);
1202
0a2aa8fb
JK		 1203 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
1204 f2fs_unlock_op(sbi);
b4ace337
CY		 1205 return ret;
1206}
1207
1208static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
1209{
1210 pgoff_t pg_start, pg_end;
1211 loff_t new_size;
1212 int ret;
1213
b4ace337
CY		 1214 if (offset + len >= i_size_read(inode))
1215 return -EINVAL;
1216
1217 /* collapse range should be aligned to block size of f2fs. */
1218 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1219 return -EINVAL;
1220
b9d777b8
JK		 1221 ret = f2fs_convert_inline_inode(inode);
1222 if (ret)
1223 return ret;
97a7b2c2 1224
09cbfeaf
KS		 1225 pg_start = offset >> PAGE_SHIFT;
1226 pg_end = (offset + len) >> PAGE_SHIFT;
b4ace337 1227
21020812 1228 /* avoid gc operation during block exchange */
b2532c69 1229 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
21020812 1230
5a3a2d83 1231 down_write(&F2FS_I(inode)->i_mmap_sem);
b4ace337
CY		 1232 /* write out all dirty pages from offset */
1233 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1234 if (ret)
21020812 1235 goto out_unlock;
bb06664a 1236
b4ace337
CY		 1237 truncate_pagecache(inode, offset);
1238
1239 ret = f2fs_do_collapse(inode, pg_start, pg_end);
1240 if (ret)
bb06664a 1241 goto out_unlock;
b4ace337 1242
6e2c64ad
JK		 1243 /* write out all moved pages, if possible */
1244 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1245 truncate_pagecache(inode, offset);
1246
b4ace337 1247 new_size = i_size_read(inode) - len;
6e2c64ad 1248 truncate_pagecache(inode, new_size);
b4ace337 1249
4d57b86d 1250 ret = f2fs_truncate_blocks(inode, new_size, true);
b4ace337 1251 if (!ret)
fc9581c8 1252 f2fs_i_size_write(inode, new_size);
bb06664a 1253out_unlock:
5a3a2d83 1254 up_write(&F2FS_I(inode)->i_mmap_sem);
b2532c69 1255 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
b4ace337
CY		 1256 return ret;
1257}
1258
6e961949
CY		 1259static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
1260 pgoff_t end)
1261{
1262 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
1263 pgoff_t index = start;
1264 unsigned int ofs_in_node = dn->ofs_in_node;
1265 blkcnt_t count = 0;
1266 int ret;
1267
1268 for (; index < end; index++, dn->ofs_in_node++) {
7a2af766
CY		 1269 if (datablock_addr(dn->inode, dn->node_page,
1270 dn->ofs_in_node) == NULL_ADDR)
6e961949
CY		 1271 count++;
1272 }
1273
1274 dn->ofs_in_node = ofs_in_node;
4d57b86d 1275 ret = f2fs_reserve_new_blocks(dn, count);
6e961949
CY		 1276 if (ret)
1277 return ret;
1278
1279 dn->ofs_in_node = ofs_in_node;
1280 for (index = start; index < end; index++, dn->ofs_in_node++) {
7a2af766
CY		 1281 dn->data_blkaddr = datablock_addr(dn->inode,
1282 dn->node_page, dn->ofs_in_node);
6e961949 1283 /*
4d57b86d 1284 * f2fs_reserve_new_blocks will not guarantee entire block
6e961949
CY		 1285 * allocation.
1286 */
1287 if (dn->data_blkaddr == NULL_ADDR) {
1288 ret = -ENOSPC;
1289 break;
1290 }
1291 if (dn->data_blkaddr != NEW_ADDR) {
4d57b86d 1292 f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
6e961949 1293 dn->data_blkaddr = NEW_ADDR;
4d57b86d 1294 f2fs_set_data_blkaddr(dn);
6e961949
CY		 1295 }
1296 }
1297
1298 f2fs_update_extent_cache_range(dn, start, 0, index - start);
1299
1300 return ret;
1301}
1302
75cd4e09
CY		 1303static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1304 int mode)
1305{
1306 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1307 struct address_space *mapping = inode->i_mapping;
1308 pgoff_t index, pg_start, pg_end;
1309 loff_t new_size = i_size_read(inode);
1310 loff_t off_start, off_end;
1311 int ret = 0;
1312
75cd4e09
CY		 1313 ret = inode_newsize_ok(inode, (len + offset));
1314 if (ret)
1315 return ret;
1316
b9d777b8
JK		 1317 ret = f2fs_convert_inline_inode(inode);
1318 if (ret)
1319 return ret;
75cd4e09 1320
5a3a2d83 1321 down_write(&F2FS_I(inode)->i_mmap_sem);
75cd4e09
CY		 1322 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
1323 if (ret)
5a3a2d83 1324 goto out_sem;
75cd4e09 1325
09cbfeaf
KS		 1326 pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
1327 pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
75cd4e09 1328
09cbfeaf
KS		 1329 off_start = offset & (PAGE_SIZE - 1);
1330 off_end = (offset + len) & (PAGE_SIZE - 1);
75cd4e09
CY		 1331
1332 if (pg_start == pg_end) {
6394328a
CY		 1333 ret = fill_zero(inode, pg_start, off_start,
1334 off_end - off_start);
1335 if (ret)
5a3a2d83 1336 goto out_sem;
6394328a 1337
75cd4e09
CY		 1338 new_size = max_t(loff_t, new_size, offset + len);
1339 } else {
1340 if (off_start) {
6394328a 1341 ret = fill_zero(inode, pg_start++, off_start,
09cbfeaf 1342 PAGE_SIZE - off_start);
6394328a 1343 if (ret)
5a3a2d83 1344 goto out_sem;
6394328a 1345
75cd4e09 1346 new_size = max_t(loff_t, new_size,
09cbfeaf 1347 (loff_t)pg_start << PAGE_SHIFT);
75cd4e09
CY		 1348 }
1349
6e961949 1350 for (index = pg_start; index < pg_end;) {
75cd4e09 1351 struct dnode_of_data dn;
6e961949
CY		 1352 unsigned int end_offset;
1353 pgoff_t end;
75cd4e09 1354
c7079853
CY		 1355 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1356
1357 truncate_pagecache_range(inode,
1358 (loff_t)index << PAGE_SHIFT,
1359 ((loff_t)pg_end << PAGE_SHIFT) - 1);
1360
75cd4e09
CY		 1361 f2fs_lock_op(sbi);
1362
6e961949 1363 set_new_dnode(&dn, inode, NULL, NULL, 0);
4d57b86d 1364 ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
75cd4e09
CY		 1365 if (ret) {
1366 f2fs_unlock_op(sbi);
c7079853 1367 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
75cd4e09
CY		 1368 goto out;
1369 }
1370
6e961949
CY		 1371 end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
1372 end = min(pg_end, end_offset - dn.ofs_in_node + index);
1373
1374 ret = f2fs_do_zero_range(&dn, index, end);
75cd4e09 1375 f2fs_put_dnode(&dn);
c7079853 1376
75cd4e09 1377 f2fs_unlock_op(sbi);
c7079853 1378 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
9434fcde
CY		 1379
1380 f2fs_balance_fs(sbi, dn.node_changed);
1381
6e961949
CY		 1382 if (ret)
1383 goto out;
75cd4e09 1384
6e961949 1385 index = end;
75cd4e09 1386 new_size = max_t(loff_t, new_size,
6e961949 1387 (loff_t)index << PAGE_SHIFT);
75cd4e09
CY		 1388 }
1389
1390 if (off_end) {
6394328a
CY		 1391 ret = fill_zero(inode, pg_end, 0, off_end);
1392 if (ret)
1393 goto out;
1394
75cd4e09
CY		 1395 new_size = max_t(loff_t, new_size, offset + len);
1396 }
1397 }
1398
1399out:
17cd07ae
CY		 1400 if (new_size > i_size_read(inode)) {
1401 if (mode & FALLOC_FL_KEEP_SIZE)
1402 file_set_keep_isize(inode);
1403 else
1404 f2fs_i_size_write(inode, new_size);
1405 }
5a3a2d83
QS		 1406out_sem:
1407 up_write(&F2FS_I(inode)->i_mmap_sem);
75cd4e09
CY		 1408
1409 return ret;
1410}
1411
f62185d0
CY		 1412static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1413{
1414 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
0a2aa8fb 1415 pgoff_t nr, pg_start, pg_end, delta, idx;
f62185d0 1416 loff_t new_size;
6e2c64ad 1417 int ret = 0;
f62185d0 1418
f62185d0 1419 new_size = i_size_read(inode) + len;
46e82fb1
KM		 1420 ret = inode_newsize_ok(inode, new_size);
1421 if (ret)
1422 return ret;
f62185d0
CY		 1423
1424 if (offset >= i_size_read(inode))
1425 return -EINVAL;
1426
1427 /* insert range should be aligned to block size of f2fs. */
1428 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
1429 return -EINVAL;
1430
b9d777b8
JK		 1431 ret = f2fs_convert_inline_inode(inode);
1432 if (ret)
1433 return ret;
97a7b2c2 1434
2c4db1a6 1435 f2fs_balance_fs(sbi, true);
2a340760 1436
21020812 1437 /* avoid gc operation during block exchange */
b2532c69 1438 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
21020812 1439
5a3a2d83 1440 down_write(&F2FS_I(inode)->i_mmap_sem);
4d57b86d 1441 ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);
f62185d0 1442 if (ret)
5a3a2d83 1443 goto out;
f62185d0
CY		 1444
1445 /* write out all dirty pages from offset */
1446 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1447 if (ret)
5a3a2d83 1448 goto out;
f62185d0
CY		 1449
1450 truncate_pagecache(inode, offset);
1451
09cbfeaf
KS		 1452 pg_start = offset >> PAGE_SHIFT;
1453 pg_end = (offset + len) >> PAGE_SHIFT;
f62185d0 1454 delta = pg_end - pg_start;
0a2aa8fb
JK		 1455 idx = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1456
1457 while (!ret && idx > pg_start) {
1458 nr = idx - pg_start;
1459 if (nr > delta)
1460 nr = delta;
1461 idx -= nr;
f62185d0 1462
f62185d0 1463 f2fs_lock_op(sbi);
5f281fab
JK		 1464 f2fs_drop_extent_tree(inode);
1465
0a2aa8fb
JK		 1466 ret = __exchange_data_block(inode, inode, idx,
1467 idx + delta, nr, false);
f62185d0
CY		 1468 f2fs_unlock_op(sbi);
1469 }
1470
6e2c64ad
JK		 1471 /* write out all moved pages, if possible */
1472 filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
1473 truncate_pagecache(inode, offset);
1474
1475 if (!ret)
fc9581c8 1476 f2fs_i_size_write(inode, new_size);
5a3a2d83
QS		 1477out:
1478 up_write(&F2FS_I(inode)->i_mmap_sem);
b2532c69 1479 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
f62185d0
CY		 1480 return ret;
1481}
1482
fbfa2cc5
JK		 1483static int expand_inode_data(struct inode *inode, loff_t offset,
1484 loff_t len, int mode)
1485{
4081363f 1486 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
d5097be5 1487 struct f2fs_map_blocks map = { .m_next_pgofs = NULL,
c4020b2d 1488 .m_next_extent = NULL, .m_seg_type = NO_CHECK_TYPE };
e12dd7bd 1489 pgoff_t pg_end;
fbfa2cc5 1490 loff_t new_size = i_size_read(inode);
e12dd7bd 1491 loff_t off_end;
a7de6086 1492 int err;
fbfa2cc5 1493
a7de6086
JK		 1494 err = inode_newsize_ok(inode, (len + offset));
1495 if (err)
1496 return err;
fbfa2cc5 1497
a7de6086
JK		 1498 err = f2fs_convert_inline_inode(inode);
1499 if (err)
1500 return err;
9e09fc85 1501
2c4db1a6 1502 f2fs_balance_fs(sbi, true);
2a340760 1503
e12dd7bd 1504 pg_end = ((unsigned long long)offset + len) >> PAGE_SHIFT;
09cbfeaf 1505 off_end = (offset + len) & (PAGE_SIZE - 1);
fbfa2cc5 1506
e12dd7bd
JK		 1507 map.m_lblk = ((unsigned long long)offset) >> PAGE_SHIFT;
1508 map.m_len = pg_end - map.m_lblk;
1509 if (off_end)
1510 map.m_len++;
ead43275 1511
a7de6086
JK		 1512 err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
1513 if (err) {
e12dd7bd 1514 pgoff_t last_off;
fbfa2cc5 1515
e12dd7bd 1516 if (!map.m_len)
a7de6086 1517 return err;
98397ff3 1518
e12dd7bd
JK		 1519 last_off = map.m_lblk + map.m_len - 1;
1520
1521 /* update new size to the failed position */
1061fd48 1522 new_size = (last_off == pg_end) ? offset + len :
e12dd7bd
JK		 1523 (loff_t)(last_off + 1) << PAGE_SHIFT;
1524 } else {
1525 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
fbfa2cc5
JK		 1526 }
1527
e8ed90a6
CY		 1528 if (new_size > i_size_read(inode)) {
1529 if (mode & FALLOC_FL_KEEP_SIZE)
1530 file_set_keep_isize(inode);
1531 else
1532 f2fs_i_size_write(inode, new_size);
1533 }
fbfa2cc5 1534
a7de6086 1535 return err;
fbfa2cc5
JK		 1536}
1537
1538static long f2fs_fallocate(struct file *file, int mode,
1539 loff_t offset, loff_t len)
1540{
6131ffaa 1541 struct inode *inode = file_inode(file);
587c0a42 1542 long ret = 0;
fbfa2cc5 1543
1f227a3e
JK		 1544 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
1545 return -EIO;
1546
c998012b
CY		 1547 /* f2fs only support ->fallocate for regular file */
1548 if (!S_ISREG(inode->i_mode))
1549 return -EINVAL;
1550
f62185d0
CY		 1551 if (f2fs_encrypted_inode(inode) &&
1552 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
fcc85a4d
JK		 1553 return -EOPNOTSUPP;
1554
b4ace337 1555 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
f62185d0
CY		 1556 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
1557 FALLOC_FL_INSERT_RANGE))
fbfa2cc5
JK		 1558 return -EOPNOTSUPP;
1559
5955102c 1560 inode_lock(inode);
3375f696 1561
587c0a42
TY		 1562 if (mode & FALLOC_FL_PUNCH_HOLE) {
1563 if (offset >= inode->i_size)
1564 goto out;
1565
a66c7b2f 1566 ret = punch_hole(inode, offset, len);
b4ace337
CY		 1567 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1568 ret = f2fs_collapse_range(inode, offset, len);
75cd4e09
CY		 1569 } else if (mode & FALLOC_FL_ZERO_RANGE) {
1570 ret = f2fs_zero_range(inode, offset, len, mode);
f62185d0
CY		 1571 } else if (mode & FALLOC_FL_INSERT_RANGE) {
1572 ret = f2fs_insert_range(inode, offset, len);
b4ace337 1573 } else {
fbfa2cc5 1574 ret = expand_inode_data(inode, offset, len, mode);
b4ace337 1575 }
fbfa2cc5 1576
3af60a49 1577 if (!ret) {
078cd827 1578 inode->i_mtime = inode->i_ctime = current_time(inode);
7c45729a 1579 f2fs_mark_inode_dirty_sync(inode, false);
d0239e1b 1580 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
3af60a49 1581 }
3375f696 1582
587c0a42 1583out:
5955102c 1584 inode_unlock(inode);
3375f696 1585
c01e2853 1586 trace_f2fs_fallocate(inode, mode, offset, len, ret);
fbfa2cc5
JK		 1587 return ret;
1588}
1589
1e84371f
JK		 1590static int f2fs_release_file(struct inode *inode, struct file *filp)
1591{
de5307e4
JK		 1592 /*
1593 * f2fs_relase_file is called at every close calls. So we should
1594 * not drop any inmemory pages by close called by other process.
1595 */
1596 if (!(filp->f_mode & FMODE_WRITE) ||
1597 atomic_read(&inode->i_writecount) != 1)
1598 return 0;
1599
1e84371f
JK		 1600 /* some remained atomic pages should discarded */
1601 if (f2fs_is_atomic_file(inode))
4d57b86d 1602 f2fs_drop_inmem_pages(inode);
1e84371f 1603 if (f2fs_is_volatile_file(inode)) {
91942321 1604 set_inode_flag(inode, FI_DROP_CACHE);
1e84371f 1605 filemap_fdatawrite(inode->i_mapping);
91942321 1606 clear_inode_flag(inode, FI_DROP_CACHE);
dfa74280
CY		 1607 clear_inode_flag(inode, FI_VOLATILE_FILE);
1608 stat_dec_volatile_write(inode);
1e84371f
JK		 1609 }
1610 return 0;
1611}
1612
7a10f017 1613static int f2fs_file_flush(struct file *file, fl_owner_t id)
fbfa2cc5 1614{
7a10f017
JK		 1615 struct inode *inode = file_inode(file);
1616
1617 /*
1618 * If the process doing a transaction is crashed, we should do
1619 * roll-back. Otherwise, other reader/write can see corrupted database
1620 * until all the writers close its file. Since this should be done
1621 * before dropping file lock, it needs to do in ->flush.
1622 */
1623 if (f2fs_is_atomic_file(inode) &&
1624 F2FS_I(inode)->inmem_task == current)
4d57b86d 1625 f2fs_drop_inmem_pages(inode);
7a10f017 1626 return 0;
fbfa2cc5
JK		 1627}
1628
52656e6c 1629static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
fbfa2cc5 1630{
6131ffaa 1631 struct inode *inode = file_inode(filp);
fbfa2cc5 1632 struct f2fs_inode_info *fi = F2FS_I(inode);
76481158
CY		 1633 unsigned int flags = fi->i_flags;
1634
5b72d5e0 1635 if (f2fs_encrypted_inode(inode))
76481158
CY		 1636 flags |= F2FS_ENCRYPT_FL;
1637 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode))
1638 flags |= F2FS_INLINE_DATA_FL;
1639
1640 flags &= F2FS_FL_USER_VISIBLE;
1641
52656e6c
JK		 1642 return put_user(flags, (int __user *)arg);
1643}
fbfa2cc5 1644
2c1d0305
CY		 1645static int __f2fs_ioc_setflags(struct inode *inode, unsigned int flags)
1646{
1647 struct f2fs_inode_info *fi = F2FS_I(inode);
1648 unsigned int oldflags;
1649
1650 /* Is it quota file? Do not allow user to mess with it */
1651 if (IS_NOQUOTA(inode))
1652 return -EPERM;
1653
1654 flags = f2fs_mask_flags(inode->i_mode, flags);
1655
1656 oldflags = fi->i_flags;
1657
59c84408 1658 if ((flags ^ oldflags) & (F2FS_APPEND_FL | F2FS_IMMUTABLE_FL))
2c1d0305
CY		 1659 if (!capable(CAP_LINUX_IMMUTABLE))
1660 return -EPERM;
1661
c807a7cb
CY		 1662 flags = flags & F2FS_FL_USER_MODIFIABLE;
1663 flags |= oldflags & ~F2FS_FL_USER_MODIFIABLE;
2c1d0305
CY		 1664 fi->i_flags = flags;
1665
59c84408 1666 if (fi->i_flags & F2FS_PROJINHERIT_FL)
2c1d0305
CY		 1667 set_inode_flag(inode, FI_PROJ_INHERIT);
1668 else
1669 clear_inode_flag(inode, FI_PROJ_INHERIT);
1670
1671 inode->i_ctime = current_time(inode);
1672 f2fs_set_inode_flags(inode);
1673 f2fs_mark_inode_dirty_sync(inode, false);
1674 return 0;
1675}
1676
52656e6c
JK		 1677static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1678{
1679 struct inode *inode = file_inode(filp);
69494229 1680 unsigned int flags;
52656e6c 1681 int ret;
fbfa2cc5 1682
7fb17fe4
CY		 1683 if (!inode_owner_or_capable(inode))
1684 return -EACCES;
1685
1686 if (get_user(flags, (int __user *)arg))
1687 return -EFAULT;
1688
52656e6c
JK		 1689 ret = mnt_want_write_file(filp);
1690 if (ret)
1691 return ret;
fbfa2cc5 1692
5955102c 1693 inode_lock(inode);
fbfa2cc5 1694
2c1d0305 1695 ret = __f2fs_ioc_setflags(inode, flags);
fbfa2cc5 1696
a72d4b97 1697 inode_unlock(inode);
52656e6c
JK		 1698 mnt_drop_write_file(filp);
1699 return ret;
1700}
4b2fecc8 1701
d49f3e89
CY		 1702static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
1703{
1704 struct inode *inode = file_inode(filp);
1705
1706 return put_user(inode->i_generation, (int __user *)arg);
1707}
1708
88b88a66
JK		 1709static int f2fs_ioc_start_atomic_write(struct file *filp)
1710{
1711 struct inode *inode = file_inode(filp);
f4c9c743 1712 int ret;
88b88a66
JK		 1713
1714 if (!inode_owner_or_capable(inode))
1715 return -EACCES;
1716
e811898c
JK		 1717 if (!S_ISREG(inode->i_mode))
1718 return -EINVAL;
1719
7fb17fe4
CY		 1720 ret = mnt_want_write_file(filp);
1721 if (ret)
1722 return ret;
1723
0fac558b
CY		 1724 inode_lock(inode);
1725
b2532c69 1726 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
27319ba4 1727
455e3a58
JK		 1728 if (f2fs_is_atomic_file(inode)) {
1729 if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST))
1730 ret = -EINVAL;
7fb17fe4 1731 goto out;
455e3a58 1732 }
88b88a66 1733
f4c9c743
CY		 1734 ret = f2fs_convert_inline_inode(inode);
1735 if (ret)
7fb17fe4 1736 goto out;
88b88a66 1737
c27753d6 1738 if (!get_dirty_pages(inode))
054afda9 1739 goto skip_flush;
c27753d6
JK		 1740
1741 f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING,
204706c7 1742 "Unexpected flush for atomic writes: ino=%lu, npages=%u",
c27753d6
JK		 1743 inode->i_ino, get_dirty_pages(inode));
1744 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
054afda9 1745 if (ret)
684ca7e5 1746 goto out;
054afda9 1747skip_flush:
054afda9 1748 set_inode_flag(inode, FI_ATOMIC_FILE);
2ef79ecb 1749 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
054afda9 1750 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
684ca7e5 1751
7a10f017 1752 F2FS_I(inode)->inmem_task = current;
26a28a0c
JK		 1753 stat_inc_atomic_write(inode);
1754 stat_update_max_atomic_write(inode);
684ca7e5 1755out:
b2532c69 1756 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
0fac558b 1757 inode_unlock(inode);
7fb17fe4 1758 mnt_drop_write_file(filp);
c27753d6 1759 return ret;
88b88a66
JK		 1760}
1761
1762static int f2fs_ioc_commit_atomic_write(struct file *filp)
1763{
1764 struct inode *inode = file_inode(filp);
1765 int ret;
1766
1767 if (!inode_owner_or_capable(inode))
1768 return -EACCES;
1769
1770 ret = mnt_want_write_file(filp);
1771 if (ret)
1772 return ret;
1773
0fac558b
CY		 1774 inode_lock(inode);
1775
b2532c69 1776 down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1dc0f899 1777
b169c3c5
CY		 1778 if (f2fs_is_volatile_file(inode)) {
1779 ret = -EINVAL;
7fb17fe4 1780 goto err_out;
b169c3c5 1781 }
7fb17fe4 1782
6282adbf 1783 if (f2fs_is_atomic_file(inode)) {
4d57b86d 1784 ret = f2fs_commit_inmem_pages(inode);
5fe45743 1785 if (ret)
edb27dee 1786 goto err_out;
5fe45743 1787
26a28a0c 1788 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
5fe45743
CY		 1789 if (!ret) {
1790 clear_inode_flag(inode, FI_ATOMIC_FILE);
2ef79ecb 1791 F2FS_I(inode)->i_gc_failures[GC_FAILURE_ATOMIC] = 0;
5fe45743 1792 stat_dec_atomic_write(inode);
447135a8 1793 }
26a28a0c 1794 } else {
774e1b78 1795 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
6282adbf 1796 }
edb27dee 1797err_out:
2ef79ecb
CY		 1798 if (is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST)) {
1799 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
1800 ret = -EINVAL;
1801 }
b2532c69 1802 up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
0fac558b 1803 inode_unlock(inode);
88b88a66
JK		 1804 mnt_drop_write_file(filp);
1805 return ret;
1806}
1807
02a1335f
JK		 1808static int f2fs_ioc_start_volatile_write(struct file *filp)
1809{
1810 struct inode *inode = file_inode(filp);
f4c9c743 1811 int ret;
02a1335f
JK		 1812
1813 if (!inode_owner_or_capable(inode))
1814 return -EACCES;
1815
8ff0971f
CY		 1816 if (!S_ISREG(inode->i_mode))
1817 return -EINVAL;
1818
7fb17fe4
CY		 1819 ret = mnt_want_write_file(filp);
1820 if (ret)
1821 return ret;
1822
0fac558b
CY		 1823 inode_lock(inode);
1824
1e84371f 1825 if (f2fs_is_volatile_file(inode))
7fb17fe4 1826 goto out;
1e84371f 1827
f4c9c743
CY		 1828 ret = f2fs_convert_inline_inode(inode);
1829 if (ret)
7fb17fe4 1830 goto out;
b3d208f9 1831
648d50ba
CY		 1832 stat_inc_volatile_write(inode);
1833 stat_update_max_volatile_write(inode);
1834
91942321 1835 set_inode_flag(inode, FI_VOLATILE_FILE);
d0239e1b 1836 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
7fb17fe4 1837out:
0fac558b 1838 inode_unlock(inode);
7fb17fe4
CY		 1839 mnt_drop_write_file(filp);
1840 return ret;
02a1335f
JK		 1841}
1842
1e84371f
JK		 1843static int f2fs_ioc_release_volatile_write(struct file *filp)
1844{
1845 struct inode *inode = file_inode(filp);
7fb17fe4 1846 int ret;
1e84371f
JK		 1847
1848 if (!inode_owner_or_capable(inode))
1849 return -EACCES;
1850
7fb17fe4
CY		 1851 ret = mnt_want_write_file(filp);
1852 if (ret)
1853 return ret;
1854
0fac558b
CY		 1855 inode_lock(inode);
1856
1e84371f 1857 if (!f2fs_is_volatile_file(inode))
7fb17fe4 1858 goto out;
1e84371f 1859
7fb17fe4
CY		 1860 if (!f2fs_is_first_block_written(inode)) {
1861 ret = truncate_partial_data_page(inode, 0, true);
1862 goto out;
1863 }
3c6c2beb 1864
7fb17fe4
CY		 1865 ret = punch_hole(inode, 0, F2FS_BLKSIZE);
1866out:
0fac558b 1867 inode_unlock(inode);
7fb17fe4
CY		 1868 mnt_drop_write_file(filp);
1869 return ret;
1e84371f
JK		 1870}
1871
1872static int f2fs_ioc_abort_volatile_write(struct file *filp)
1873{
1874 struct inode *inode = file_inode(filp);
1875 int ret;
1876
1877 if (!inode_owner_or_capable(inode))
1878 return -EACCES;
1879
1880 ret = mnt_want_write_file(filp);
1881 if (ret)
1882 return ret;
1883
0fac558b
CY		 1884 inode_lock(inode);
1885
26dc3d44 1886 if (f2fs_is_atomic_file(inode))
4d57b86d 1887 f2fs_drop_inmem_pages(inode);
732d5648 1888 if (f2fs_is_volatile_file(inode)) {
91942321 1889 clear_inode_flag(inode, FI_VOLATILE_FILE);
648d50ba 1890 stat_dec_volatile_write(inode);
608514de 1891 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
732d5648 1892 }
de6a8ec9 1893
455e3a58
JK		 1894 clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
1895
0fac558b
CY		 1896 inode_unlock(inode);
1897
1e84371f 1898 mnt_drop_write_file(filp);
d0239e1b 1899 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1e84371f
JK		 1900 return ret;
1901}
1902
1abff93d
JK		 1903static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
1904{
1905 struct inode *inode = file_inode(filp);
1906 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1907 struct super_block *sb = sbi->sb;
1908 __u32 in;
2a96d8ad 1909 int ret = 0;
1abff93d
JK		 1910
1911 if (!capable(CAP_SYS_ADMIN))
1912 return -EPERM;
1913
1914 if (get_user(in, (__u32 __user *)arg))
1915 return -EFAULT;
1916
60b2b4ee
ST		 1917 if (in != F2FS_GOING_DOWN_FULLSYNC) {
1918 ret = mnt_want_write_file(filp);
1919 if (ret)
1920 return ret;
1921 }
7fb17fe4 1922
1abff93d
JK		 1923 switch (in) {
1924 case F2FS_GOING_DOWN_FULLSYNC:
1925 sb = freeze_bdev(sb->s_bdev);
d027c484
CY		 1926 if (IS_ERR(sb)) {
1927 ret = PTR_ERR(sb);
1928 goto out;
1929 }
1930 if (sb) {
38f91ca8 1931 f2fs_stop_checkpoint(sbi, false);
83a3bfdb 1932 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
1abff93d
JK		 1933 thaw_bdev(sb->s_bdev, sb);
1934 }
1935 break;
1936 case F2FS_GOING_DOWN_METASYNC:
1937 /* do checkpoint only */
d027c484
CY		 1938 ret = f2fs_sync_fs(sb, 1);
1939 if (ret)
1940 goto out;
38f91ca8 1941 f2fs_stop_checkpoint(sbi, false);
83a3bfdb 1942 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
1abff93d
JK		 1943 break;
1944 case F2FS_GOING_DOWN_NOSYNC:
38f91ca8 1945 f2fs_stop_checkpoint(sbi, false);
83a3bfdb 1946 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
1abff93d 1947 break;
c912a829 1948 case F2FS_GOING_DOWN_METAFLUSH:
4d57b86d 1949 f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_META_IO);
38f91ca8 1950 f2fs_stop_checkpoint(sbi, false);
83a3bfdb 1951 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
c912a829 1952 break;
1abff93d 1953 default:
7fb17fe4
CY		 1954 ret = -EINVAL;
1955 goto out;
1abff93d 1956 }
7950e9ac 1957
4d57b86d
CY		 1958 f2fs_stop_gc_thread(sbi);
1959 f2fs_stop_discard_thread(sbi);
7950e9ac 1960
4d57b86d 1961 f2fs_drop_discard_cmd(sbi);
7950e9ac
CY		 1962 clear_opt(sbi, DISCARD);
1963
d0239e1b 1964 f2fs_update_time(sbi, REQ_TIME);
7fb17fe4 1965out:
60b2b4ee
ST		 1966 if (in != F2FS_GOING_DOWN_FULLSYNC)
1967 mnt_drop_write_file(filp);
7fb17fe4 1968 return ret;
1abff93d
JK		 1969}
1970
52656e6c
JK		 1971static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
1972{
1973 struct inode *inode = file_inode(filp);
1974 struct super_block *sb = inode->i_sb;
1975 struct request_queue *q = bdev_get_queue(sb->s_bdev);
1976 struct fstrim_range range;
1977 int ret;
4b2fecc8 1978
52656e6c
JK		 1979 if (!capable(CAP_SYS_ADMIN))
1980 return -EPERM;
4b2fecc8 1981
52656e6c
JK		 1982 if (!blk_queue_discard(q))
1983 return -EOPNOTSUPP;
4b2fecc8 1984
52656e6c
JK		 1985 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1986 sizeof(range)))
1987 return -EFAULT;
4b2fecc8 1988
7fb17fe4
CY		 1989 ret = mnt_want_write_file(filp);
1990 if (ret)
1991 return ret;
1992
52656e6c
JK		 1993 range.minlen = max((unsigned int)range.minlen,
1994 q->limits.discard_granularity);
1995 ret = f2fs_trim_fs(F2FS_SB(sb), &range);
7fb17fe4 1996 mnt_drop_write_file(filp);
52656e6c
JK		 1997 if (ret < 0)
1998 return ret;
4b2fecc8 1999
52656e6c
JK		 2000 if (copy_to_user((struct fstrim_range __user *)arg, &range,
2001 sizeof(range)))
2002 return -EFAULT;
d0239e1b 2003 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
52656e6c
JK		 2004 return 0;
2005}
2006
f424f664
JK		 2007static bool uuid_is_nonzero(__u8 u[16])
2008{
2009 int i;
2010
2011 for (i = 0; i < 16; i++)
2012 if (u[i])
2013 return true;
2014 return false;
2015}
2016
2017static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
2018{
f424f664
JK		 2019 struct inode *inode = file_inode(filp);
2020
ccd31cb2 2021 if (!f2fs_sb_has_encrypt(inode->i_sb))
ead710b7
CY		 2022 return -EOPNOTSUPP;
2023
d0239e1b 2024 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
7fb17fe4 2025
db717d8e 2026 return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
f424f664
JK		 2027}
2028
2029static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
2030{
ccd31cb2 2031 if (!f2fs_sb_has_encrypt(file_inode(filp)->i_sb))
ead710b7 2032 return -EOPNOTSUPP;
db717d8e 2033 return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
f424f664
JK		 2034}
2035
2036static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
2037{
2038 struct inode *inode = file_inode(filp);
2039 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2040 int err;
2041
ccd31cb2 2042 if (!f2fs_sb_has_encrypt(inode->i_sb))
f424f664
JK		 2043 return -EOPNOTSUPP;
2044
f424f664
JK		 2045 err = mnt_want_write_file(filp);
2046 if (err)
2047 return err;
2048
846ae671 2049 down_write(&sbi->sb_lock);
d0d3f1b3
CY		 2050
2051 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
2052 goto got_it;
2053
f424f664
JK		 2054 /* update superblock with uuid */
2055 generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
2056
c5bda1c8 2057 err = f2fs_commit_super(sbi, false);
f424f664
JK		 2058 if (err) {
2059 /* undo new data */
2060 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
d0d3f1b3 2061 goto out_err;
f424f664
JK		 2062 }
2063got_it:
2064 if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
2065 16))
d0d3f1b3
CY		 2066 err = -EFAULT;
2067out_err:
846ae671 2068 up_write(&sbi->sb_lock);
d0d3f1b3
CY		 2069 mnt_drop_write_file(filp);
2070 return err;
f424f664
JK		 2071}
2072
c1c1b583
CY		 2073static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
2074{
2075 struct inode *inode = file_inode(filp);
2076 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
d530d4d8 2077 __u32 sync;
7fb17fe4 2078 int ret;
c1c1b583
CY		 2079
2080 if (!capable(CAP_SYS_ADMIN))
2081 return -EPERM;
2082
d530d4d8 2083 if (get_user(sync, (__u32 __user *)arg))
c1c1b583
CY		 2084 return -EFAULT;
2085
d530d4d8
CY		 2086 if (f2fs_readonly(sbi->sb))
2087 return -EROFS;
c1c1b583 2088
7fb17fe4
CY		 2089 ret = mnt_want_write_file(filp);
2090 if (ret)
2091 return ret;
2092
d530d4d8 2093 if (!sync) {
7fb17fe4
CY		 2094 if (!mutex_trylock(&sbi->gc_mutex)) {
2095 ret = -EBUSY;
2096 goto out;
2097 }
d530d4d8
CY		 2098 } else {
2099 mutex_lock(&sbi->gc_mutex);
c1c1b583
CY		 2100 }
2101
e066b83c 2102 ret = f2fs_gc(sbi, sync, true, NULL_SEGNO);
7fb17fe4
CY		 2103out:
2104 mnt_drop_write_file(filp);
2105 return ret;
c1c1b583
CY		 2106}
2107
34dc77ad
JK		 2108static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg)
2109{
2110 struct inode *inode = file_inode(filp);
2111 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2112 struct f2fs_gc_range range;
2113 u64 end;
2114 int ret;
2115
2116 if (!capable(CAP_SYS_ADMIN))
2117 return -EPERM;
2118
2119 if (copy_from_user(&range, (struct f2fs_gc_range __user *)arg,
2120 sizeof(range)))
2121 return -EFAULT;
2122
2123 if (f2fs_readonly(sbi->sb))
2124 return -EROFS;
2125
b82f6e34
YH		 2126 end = range.start + range.len;
2127 if (range.start < MAIN_BLKADDR(sbi) || end >= MAX_BLKADDR(sbi)) {
2128 return -EINVAL;
2129 }
2130
34dc77ad
JK		 2131 ret = mnt_want_write_file(filp);
2132 if (ret)
2133 return ret;
2134
34dc77ad
JK		 2135do_more:
2136 if (!range.sync) {
2137 if (!mutex_trylock(&sbi->gc_mutex)) {
2138 ret = -EBUSY;
2139 goto out;
2140 }
2141 } else {
2142 mutex_lock(&sbi->gc_mutex);
2143 }
2144
2145 ret = f2fs_gc(sbi, range.sync, true, GET_SEGNO(sbi, range.start));
2146 range.start += sbi->blocks_per_seg;
2147 if (range.start <= end)
2148 goto do_more;
2149out:
2150 mnt_drop_write_file(filp);
2151 return ret;
2152}
2153
059c0648 2154static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
456b88e4
CY		 2155{
2156 struct inode *inode = file_inode(filp);
2157 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
7fb17fe4 2158 int ret;
456b88e4
CY		 2159
2160 if (!capable(CAP_SYS_ADMIN))
2161 return -EPERM;
2162
2163 if (f2fs_readonly(sbi->sb))
2164 return -EROFS;
2165
7fb17fe4
CY		 2166 ret = mnt_want_write_file(filp);
2167 if (ret)
2168 return ret;
2169
2170 ret = f2fs_sync_fs(sbi->sb, 1);
2171
2172 mnt_drop_write_file(filp);
2173 return ret;
456b88e4
CY		 2174}
2175
d323d005
CY		 2176static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
2177 struct file *filp,
2178 struct f2fs_defragment *range)
2179{
2180 struct inode *inode = file_inode(filp);
f3d98e74
CY		 2181 struct f2fs_map_blocks map = { .m_next_extent = NULL,
2182 .m_seg_type = NO_CHECK_TYPE };
1061fd48 2183 struct extent_info ei = {0, 0, 0};
f3d98e74 2184 pgoff_t pg_start, pg_end, next_pgofs;
3519e3f9 2185 unsigned int blk_per_seg = sbi->blocks_per_seg;
d323d005 2186 unsigned int total = 0, sec_num;
d323d005
CY		 2187 block_t blk_end = 0;
2188 bool fragmented = false;
2189 int err;
2190
2191 /* if in-place-update policy is enabled, don't waste time here */
4d57b86d 2192 if (f2fs_should_update_inplace(inode, NULL))
d323d005
CY		 2193 return -EINVAL;
2194
09cbfeaf
KS		 2195 pg_start = range->start >> PAGE_SHIFT;
2196 pg_end = (range->start + range->len) >> PAGE_SHIFT;
d323d005 2197
2c4db1a6 2198 f2fs_balance_fs(sbi, true);
d323d005 2199
5955102c 2200 inode_lock(inode);
d323d005
CY		 2201
2202 /* writeback all dirty pages in the range */
2203 err = filemap_write_and_wait_range(inode->i_mapping, range->start,
d8fe4f0e 2204 range->start + range->len - 1);
d323d005
CY		 2205 if (err)
2206 goto out;
2207
2208 /*
2209 * lookup mapping info in extent cache, skip defragmenting if physical
2210 * block addresses are continuous.
2211 */
2212 if (f2fs_lookup_extent_cache(inode, pg_start, &ei)) {
2213 if (ei.fofs + ei.len >= pg_end)
2214 goto out;
2215 }
2216
2217 map.m_lblk = pg_start;
f3d98e74 2218 map.m_next_pgofs = &next_pgofs;
d323d005
CY		 2219
2220 /*
2221 * lookup mapping info in dnode page cache, skip defragmenting if all
2222 * physical block addresses are continuous even if there are hole(s)
2223 * in logical blocks.
2224 */
2225 while (map.m_lblk < pg_end) {
a1c1e9b7 2226 map.m_len = pg_end - map.m_lblk;
f2220c7f 2227 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
d323d005
CY		 2228 if (err)
2229 goto out;
2230
2231 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
f3d98e74 2232 map.m_lblk = next_pgofs;
d323d005
CY		 2233 continue;
2234 }
2235
25a912e5 2236 if (blk_end && blk_end != map.m_pblk)
d323d005 2237 fragmented = true;
25a912e5
CY		 2238
2239 /* record total count of block that we're going to move */
2240 total += map.m_len;
2241
d323d005
CY		 2242 blk_end = map.m_pblk + map.m_len;
2243
2244 map.m_lblk += map.m_len;
d323d005
CY		 2245 }
2246
2247 if (!fragmented)
2248 goto out;
2249
25a912e5 2250 sec_num = (total + BLKS_PER_SEC(sbi) - 1) / BLKS_PER_SEC(sbi);
d323d005
CY		 2251
2252 /*
2253 * make sure there are enough free section for LFS allocation, this can
2254 * avoid defragment running in SSR mode when free section are allocated
2255 * intensively
2256 */
7f3037a5 2257 if (has_not_enough_free_secs(sbi, 0, sec_num)) {
d323d005
CY		 2258 err = -EAGAIN;
2259 goto out;
2260 }
2261
25a912e5
CY		 2262 map.m_lblk = pg_start;
2263 map.m_len = pg_end - pg_start;
2264 total = 0;
2265
d323d005
CY		 2266 while (map.m_lblk < pg_end) {
2267 pgoff_t idx;
2268 int cnt = 0;
2269
2270do_map:
a1c1e9b7 2271 map.m_len = pg_end - map.m_lblk;
f2220c7f 2272 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
d323d005
CY		 2273 if (err)
2274 goto clear_out;
2275
2276 if (!(map.m_flags & F2FS_MAP_FLAGS)) {
f3d98e74 2277 map.m_lblk = next_pgofs;
d323d005
CY		 2278 continue;
2279 }
2280
91942321 2281 set_inode_flag(inode, FI_DO_DEFRAG);
d323d005
CY		 2282
2283 idx = map.m_lblk;
2284 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
2285 struct page *page;
2286
4d57b86d 2287 page = f2fs_get_lock_data_page(inode, idx, true);
d323d005
CY		 2288 if (IS_ERR(page)) {
2289 err = PTR_ERR(page);
2290 goto clear_out;
2291 }
2292
2293 set_page_dirty(page);
2294 f2fs_put_page(page, 1);
2295
2296 idx++;
2297 cnt++;
2298 total++;
2299 }
2300
2301 map.m_lblk = idx;
d323d005
CY		 2302
2303 if (idx < pg_end && cnt < blk_per_seg)
2304 goto do_map;
2305
91942321 2306 clear_inode_flag(inode, FI_DO_DEFRAG);
d323d005
CY		 2307
2308 err = filemap_fdatawrite(inode->i_mapping);
2309 if (err)
2310 goto out;
2311 }
2312clear_out:
91942321 2313 clear_inode_flag(inode, FI_DO_DEFRAG);
d323d005 2314out:
5955102c 2315 inode_unlock(inode);
d323d005 2316 if (!err)
09cbfeaf 2317 range->len = (u64)total << PAGE_SHIFT;
d323d005
CY		 2318 return err;
2319}
2320
2321static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
2322{
2323 struct inode *inode = file_inode(filp);
2324 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2325 struct f2fs_defragment range;
2326 int err;
2327
2328 if (!capable(CAP_SYS_ADMIN))
2329 return -EPERM;
2330
7eab0c0d 2331 if (!S_ISREG(inode->i_mode) || f2fs_is_atomic_file(inode))
d323d005
CY		 2332 return -EINVAL;
2333
d7563861
KM		 2334 if (f2fs_readonly(sbi->sb))
2335 return -EROFS;
d323d005
CY		 2336
2337 if (copy_from_user(&range, (struct f2fs_defragment __user *)arg,
d7563861
KM		 2338 sizeof(range)))
2339 return -EFAULT;
d323d005
CY		 2340
2341 /* verify alignment of offset & size */
d7563861
KM		 2342 if (range.start & (F2FS_BLKSIZE - 1) || range.len & (F2FS_BLKSIZE - 1))
2343 return -EINVAL;
d323d005 2344
1941d7bc 2345 if (unlikely((range.start + range.len) >> PAGE_SHIFT >
d7563861
KM		 2346 sbi->max_file_blocks))
2347 return -EINVAL;
2348
2349 err = mnt_want_write_file(filp);
2350 if (err)
2351 return err;
1941d7bc 2352
d323d005 2353 err = f2fs_defragment_range(sbi, filp, &range);
d7563861
KM		 2354 mnt_drop_write_file(filp);
2355
d0239e1b 2356 f2fs_update_time(sbi, REQ_TIME);
d323d005 2357 if (err < 0)
d7563861 2358 return err;
d323d005
CY		 2359
2360 if (copy_to_user((struct f2fs_defragment __user *)arg, &range,
2361 sizeof(range)))
d7563861
KM		 2362 return -EFAULT;
2363
2364 return 0;
d323d005
CY		 2365}
2366
4dd6f977
JK		 2367static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2368 struct file *file_out, loff_t pos_out, size_t len)
2369{
2370 struct inode *src = file_inode(file_in);
2371 struct inode *dst = file_inode(file_out);
2372 struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2373 size_t olen = len, dst_max_i_size = 0;
2374 size_t dst_osize;
2375 int ret;
2376
2377 if (file_in->f_path.mnt != file_out->f_path.mnt ||
2378 src->i_sb != dst->i_sb)
2379 return -EXDEV;
2380
2381 if (unlikely(f2fs_readonly(src->i_sb)))
2382 return -EROFS;
2383
fe8494bf
CY		 2384 if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))
2385 return -EINVAL;
4dd6f977
JK		 2386
2387 if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst))
2388 return -EOPNOTSUPP;
2389
d95fd91c
FL		 2390 if (src == dst) {
2391 if (pos_in == pos_out)
2392 return 0;
2393 if (pos_out > pos_in && pos_out < pos_in + len)
2394 return -EINVAL;
2395 }
2396
4dd6f977 2397 inode_lock(src);
b2532c69 2398 down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
20a3d61d 2399 if (src != dst) {
bb06664a
CY		 2400 ret = -EBUSY;
2401 if (!inode_trylock(dst))
2402 goto out;
b2532c69 2403 if (!down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE])) {
bb06664a 2404 inode_unlock(dst);
20a3d61d
CY		 2405 goto out;
2406 }
2407 }
4dd6f977
JK		 2408
2409 ret = -EINVAL;
2410 if (pos_in + len > src->i_size || pos_in + len < pos_in)
2411 goto out_unlock;
2412 if (len == 0)
2413 olen = len = src->i_size - pos_in;
2414 if (pos_in + len == src->i_size)
2415 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2416 if (len == 0) {
2417 ret = 0;
2418 goto out_unlock;
2419 }
2420
2421 dst_osize = dst->i_size;
2422 if (pos_out + olen > dst->i_size)
2423 dst_max_i_size = pos_out + olen;
2424
2425 /* verify the end result is block aligned */
2426 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2427 !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2428 !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2429 goto out_unlock;
2430
2431 ret = f2fs_convert_inline_inode(src);
2432 if (ret)
2433 goto out_unlock;
2434
2435 ret = f2fs_convert_inline_inode(dst);
2436 if (ret)
2437 goto out_unlock;
2438
2439 /* write out all dirty pages from offset */
2440 ret = filemap_write_and_wait_range(src->i_mapping,
2441 pos_in, pos_in + len);
2442 if (ret)
2443 goto out_unlock;
2444
2445 ret = filemap_write_and_wait_range(dst->i_mapping,
2446 pos_out, pos_out + len);
2447 if (ret)
2448 goto out_unlock;
2449
2450 f2fs_balance_fs(sbi, true);
2451 f2fs_lock_op(sbi);
61e4da11
FL		 2452 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2453 pos_out >> F2FS_BLKSIZE_BITS,
2454 len >> F2FS_BLKSIZE_BITS, false);
4dd6f977
JK		 2455
2456 if (!ret) {
2457 if (dst_max_i_size)
2458 f2fs_i_size_write(dst, dst_max_i_size);
2459 else if (dst_osize != dst->i_size)
2460 f2fs_i_size_write(dst, dst_osize);
2461 }
2462 f2fs_unlock_op(sbi);
2463out_unlock:
bb06664a 2464 if (src != dst) {
b2532c69 2465 up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
4dd6f977 2466 inode_unlock(dst);
bb06664a 2467 }
20a3d61d 2468out:
b2532c69 2469 up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
4dd6f977
JK		 2470 inode_unlock(src);
2471 return ret;
2472}
2473
2474static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
2475{
2476 struct f2fs_move_range range;
2477 struct fd dst;
2478 int err;
2479
2480 if (!(filp->f_mode & FMODE_READ) ||
2481 !(filp->f_mode & FMODE_WRITE))
2482 return -EBADF;
2483
2484 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
2485 sizeof(range)))
2486 return -EFAULT;
2487
2488 dst = fdget(range.dst_fd);
2489 if (!dst.file)
2490 return -EBADF;
2491
2492 if (!(dst.file->f_mode & FMODE_WRITE)) {
2493 err = -EBADF;
2494 goto err_out;
2495 }
2496
2497 err = mnt_want_write_file(filp);
2498 if (err)
2499 goto err_out;
2500
2501 err = f2fs_move_file_range(filp, range.pos_in, dst.file,
2502 range.pos_out, range.len);
2503
2504 mnt_drop_write_file(filp);
3cecfa5f
KM		 2505 if (err)
2506 goto err_out;
4dd6f977
JK		 2507
2508 if (copy_to_user((struct f2fs_move_range __user *)arg,
2509 &range, sizeof(range)))
2510 err = -EFAULT;
2511err_out:
2512 fdput(dst);
2513 return err;
2514}
2515
e066b83c
JK		 2516static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
2517{
2518 struct inode *inode = file_inode(filp);
2519 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2520 struct sit_info *sm = SIT_I(sbi);
2521 unsigned int start_segno = 0, end_segno = 0;
2522 unsigned int dev_start_segno = 0, dev_end_segno = 0;
2523 struct f2fs_flush_device range;
2524 int ret;
2525
2526 if (!capable(CAP_SYS_ADMIN))
2527 return -EPERM;
2528
2529 if (f2fs_readonly(sbi->sb))
2530 return -EROFS;
2531
2532 if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
2533 sizeof(range)))
2534 return -EFAULT;
2535
2536 if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num ||
2537 sbi->segs_per_sec != 1) {
2538 f2fs_msg(sbi->sb, KERN_WARNING,
2539 "Can't flush %u in %d for segs_per_sec %u != 1\n",
2540 range.dev_num, sbi->s_ndevs,
2541 sbi->segs_per_sec);
2542 return -EINVAL;
2543 }
2544
2545 ret = mnt_want_write_file(filp);
2546 if (ret)
2547 return ret;
2548
2549 if (range.dev_num != 0)
2550 dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk);
2551 dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk);
2552
2553 start_segno = sm->last_victim[FLUSH_DEVICE];
2554 if (start_segno < dev_start_segno || start_segno >= dev_end_segno)
2555 start_segno = dev_start_segno;
2556 end_segno = min(start_segno + range.segments, dev_end_segno);
2557
2558 while (start_segno < end_segno) {
2559 if (!mutex_trylock(&sbi->gc_mutex)) {
2560 ret = -EBUSY;
2561 goto out;
2562 }
2563 sm->last_victim[GC_CB] = end_segno + 1;
2564 sm->last_victim[GC_GREEDY] = end_segno + 1;
2565 sm->last_victim[ALLOC_NEXT] = end_segno + 1;
2566 ret = f2fs_gc(sbi, true, true, start_segno);
2567 if (ret == -EAGAIN)
2568 ret = 0;
2569 else if (ret < 0)
2570 break;
2571 start_segno++;
2572 }
2573out:
2574 mnt_drop_write_file(filp);
2575 return ret;
2576}
2577
e65ef207
JK		 2578static int f2fs_ioc_get_features(struct file *filp, unsigned long arg)
2579{
2580 struct inode *inode = file_inode(filp);
2581 u32 sb_feature = le32_to_cpu(F2FS_I_SB(inode)->raw_super->feature);
2582
2583 /* Must validate to set it with SQLite behavior in Android. */
2584 sb_feature |= F2FS_FEATURE_ATOMIC_WRITE;
2585
2586 return put_user(sb_feature, (u32 __user *)arg);
2587}
e066b83c 2588
2c1d0305
CY		 2589#ifdef CONFIG_QUOTA
2590static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
2591{
2592 struct inode *inode = file_inode(filp);
2593 struct f2fs_inode_info *fi = F2FS_I(inode);
2594 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2595 struct super_block *sb = sbi->sb;
2596 struct dquot *transfer_to[MAXQUOTAS] = {};
2597 struct page *ipage;
2598 kprojid_t kprojid;
2599 int err;
2600
2601 if (!f2fs_sb_has_project_quota(sb)) {
2602 if (projid != F2FS_DEF_PROJID)
2603 return -EOPNOTSUPP;
2604 else
2605 return 0;
2606 }
2607
2608 if (!f2fs_has_extra_attr(inode))
2609 return -EOPNOTSUPP;
2610
2611 kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
2612
2613 if (projid_eq(kprojid, F2FS_I(inode)->i_projid))
2614 return 0;
2615
2616 err = mnt_want_write_file(filp);
2617 if (err)
2618 return err;
2619
2620 err = -EPERM;
2621 inode_lock(inode);
2622
2623 /* Is it quota file? Do not allow user to mess with it */
2624 if (IS_NOQUOTA(inode))
2625 goto out_unlock;
2626
4d57b86d 2627 ipage = f2fs_get_node_page(sbi, inode->i_ino);
2c1d0305
CY		 2628 if (IS_ERR(ipage)) {
2629 err = PTR_ERR(ipage);
2630 goto out_unlock;
2631 }
2632
2633 if (!F2FS_FITS_IN_INODE(F2FS_INODE(ipage), fi->i_extra_isize,
2634 i_projid)) {
2635 err = -EOVERFLOW;
2636 f2fs_put_page(ipage, 1);
2637 goto out_unlock;
2638 }
2639 f2fs_put_page(ipage, 1);
2640
c22aecd7
CY		 2641 err = dquot_initialize(inode);
2642 if (err)
2643 goto out_unlock;
2c1d0305
CY		 2644
2645 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
2646 if (!IS_ERR(transfer_to[PRJQUOTA])) {
2647 err = __dquot_transfer(inode, transfer_to);
2648 dqput(transfer_to[PRJQUOTA]);
2649 if (err)
2650 goto out_dirty;
2651 }
2652
2653 F2FS_I(inode)->i_projid = kprojid;
2654 inode->i_ctime = current_time(inode);
2655out_dirty:
2656 f2fs_mark_inode_dirty_sync(inode, true);
2657out_unlock:
2658 inode_unlock(inode);
2659 mnt_drop_write_file(filp);
2660 return err;
2661}
2662#else
2663static int f2fs_ioc_setproject(struct file *filp, __u32 projid)
2664{
2665 if (projid != F2FS_DEF_PROJID)
2666 return -EOPNOTSUPP;
2667 return 0;
2668}
2669#endif
2670
2671/* Transfer internal flags to xflags */
2672static inline __u32 f2fs_iflags_to_xflags(unsigned long iflags)
2673{
2674 __u32 xflags = 0;
2675
59c84408 2676 if (iflags & F2FS_SYNC_FL)
2c1d0305 2677 xflags |= FS_XFLAG_SYNC;
59c84408 2678 if (iflags & F2FS_IMMUTABLE_FL)
2c1d0305 2679 xflags |= FS_XFLAG_IMMUTABLE;
59c84408 2680 if (iflags & F2FS_APPEND_FL)
2c1d0305 2681 xflags |= FS_XFLAG_APPEND;
59c84408 2682 if (iflags & F2FS_NODUMP_FL)
2c1d0305 2683 xflags |= FS_XFLAG_NODUMP;
59c84408 2684 if (iflags & F2FS_NOATIME_FL)
2c1d0305 2685 xflags |= FS_XFLAG_NOATIME;
59c84408 2686 if (iflags & F2FS_PROJINHERIT_FL)
2c1d0305
CY		 2687 xflags |= FS_XFLAG_PROJINHERIT;
2688 return xflags;
2689}
2690
2691#define F2FS_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
2692 FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
2693 FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT)
2694
2c1d0305
CY		 2695/* Transfer xflags flags to internal */
2696static inline unsigned long f2fs_xflags_to_iflags(__u32 xflags)
2697{
2698 unsigned long iflags = 0;
2699
2700 if (xflags & FS_XFLAG_SYNC)
59c84408 2701 iflags |= F2FS_SYNC_FL;
2c1d0305 2702 if (xflags & FS_XFLAG_IMMUTABLE)
59c84408 2703 iflags |= F2FS_IMMUTABLE_FL;
2c1d0305 2704 if (xflags & FS_XFLAG_APPEND)
59c84408 2705 iflags |= F2FS_APPEND_FL;
2c1d0305 2706 if (xflags & FS_XFLAG_NODUMP)
59c84408 2707 iflags |= F2FS_NODUMP_FL;
2c1d0305 2708 if (xflags & FS_XFLAG_NOATIME)
59c84408 2709 iflags |= F2FS_NOATIME_FL;
2c1d0305 2710 if (xflags & FS_XFLAG_PROJINHERIT)
59c84408 2711 iflags |= F2FS_PROJINHERIT_FL;
2c1d0305
CY		 2712
2713 return iflags;
2714}
2715
2716static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg)
2717{
2718 struct inode *inode = file_inode(filp);
2719 struct f2fs_inode_info *fi = F2FS_I(inode);
2720 struct fsxattr fa;
2721
2722 memset(&fa, 0, sizeof(struct fsxattr));
2723 fa.fsx_xflags = f2fs_iflags_to_xflags(fi->i_flags &
c807a7cb 2724 F2FS_FL_USER_VISIBLE);
2c1d0305
CY		 2725
2726 if (f2fs_sb_has_project_quota(inode->i_sb))
2727 fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
2728 fi->i_projid);
2729
2730 if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa)))
2731 return -EFAULT;
2732 return 0;
2733}
2734
2735static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg)
2736{
2737 struct inode *inode = file_inode(filp);
2738 struct f2fs_inode_info *fi = F2FS_I(inode);
2739 struct fsxattr fa;
2740 unsigned int flags;
2741 int err;
2742
2743 if (copy_from_user(&fa, (struct fsxattr __user *)arg, sizeof(fa)))
2744 return -EFAULT;
2745
2746 /* Make sure caller has proper permission */
2747 if (!inode_owner_or_capable(inode))
2748 return -EACCES;
2749
2750 if (fa.fsx_xflags & ~F2FS_SUPPORTED_FS_XFLAGS)
2751 return -EOPNOTSUPP;
2752
2753 flags = f2fs_xflags_to_iflags(fa.fsx_xflags);
2754 if (f2fs_mask_flags(inode->i_mode, flags) != flags)
2755 return -EOPNOTSUPP;
2756
2757 err = mnt_want_write_file(filp);
2758 if (err)
2759 return err;
2760
2761 inode_lock(inode);
2762 flags = (fi->i_flags & ~F2FS_FL_XFLAG_VISIBLE) |
2763 (flags & F2FS_FL_XFLAG_VISIBLE);
2764 err = __f2fs_ioc_setflags(inode, flags);
2765 inode_unlock(inode);
2766 mnt_drop_write_file(filp);
2767 if (err)
2768 return err;
2769
2770 err = f2fs_ioc_setproject(filp, fa.fsx_projid);
2771 if (err)
2772 return err;
2773
2774 return 0;
2775}
e066b83c 2776
1ad71a27
JK		 2777int f2fs_pin_file_control(struct inode *inode, bool inc)
2778{
2779 struct f2fs_inode_info *fi = F2FS_I(inode);
2780 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2781
2782 /* Use i_gc_failures for normal file as a risk signal. */
2783 if (inc)
2ef79ecb
CY		 2784 f2fs_i_gc_failures_write(inode,
2785 fi->i_gc_failures[GC_FAILURE_PIN] + 1);
1ad71a27 2786
2ef79ecb 2787 if (fi->i_gc_failures[GC_FAILURE_PIN] > sbi->gc_pin_file_threshold) {
1ad71a27
JK		 2788 f2fs_msg(sbi->sb, KERN_WARNING,
2789 "%s: Enable GC = ino %lx after %x GC trials\n",
2ef79ecb
CY		 2790 __func__, inode->i_ino,
2791 fi->i_gc_failures[GC_FAILURE_PIN]);
1ad71a27
JK		 2792 clear_inode_flag(inode, FI_PIN_FILE);
2793 return -EAGAIN;
2794 }
2795 return 0;
2796}
2797
2798static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
2799{
2800 struct inode *inode = file_inode(filp);
2801 __u32 pin;
2802 int ret = 0;
2803
2804 if (!inode_owner_or_capable(inode))
2805 return -EACCES;
2806
2807 if (get_user(pin, (__u32 __user *)arg))
2808 return -EFAULT;
2809
2810 if (!S_ISREG(inode->i_mode))
2811 return -EINVAL;
2812
2813 if (f2fs_readonly(F2FS_I_SB(inode)->sb))
2814 return -EROFS;
2815
2816 ret = mnt_want_write_file(filp);
2817 if (ret)
2818 return ret;
2819
2820 inode_lock(inode);
2821
4d57b86d 2822 if (f2fs_should_update_outplace(inode, NULL)) {
bb9e3bb8
CY		 2823 ret = -EINVAL;
2824 goto out;
2825 }
2826
1ad71a27
JK		 2827 if (!pin) {
2828 clear_inode_flag(inode, FI_PIN_FILE);
30933364 2829 f2fs_i_gc_failures_write(inode, 0);
1ad71a27
JK		 2830 goto done;
2831 }
2832
2833 if (f2fs_pin_file_control(inode, false)) {
2834 ret = -EAGAIN;
2835 goto out;
2836 }
2837 ret = f2fs_convert_inline_inode(inode);
2838 if (ret)
2839 goto out;
2840
2841 set_inode_flag(inode, FI_PIN_FILE);
2ef79ecb 2842 ret = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
1ad71a27
JK		 2843done:
2844 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
2845out:
2846 inode_unlock(inode);
2847 mnt_drop_write_file(filp);
2848 return ret;
2849}
2850
2851static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg)
2852{
2853 struct inode *inode = file_inode(filp);
2854 __u32 pin = 0;
2855
2856 if (is_inode_flag_set(inode, FI_PIN_FILE))
2ef79ecb 2857 pin = F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN];
1ad71a27
JK		 2858 return put_user(pin, (u32 __user *)arg);
2859}
2860
c4020b2d
CY		 2861int f2fs_precache_extents(struct inode *inode)
2862{
2863 struct f2fs_inode_info *fi = F2FS_I(inode);
2864 struct f2fs_map_blocks map;
2865 pgoff_t m_next_extent;
2866 loff_t end;
2867 int err;
2868
2869 if (is_inode_flag_set(inode, FI_NO_EXTENT))
2870 return -EOPNOTSUPP;
2871
2872 map.m_lblk = 0;
2873 map.m_next_pgofs = NULL;
2874 map.m_next_extent = &m_next_extent;
2875 map.m_seg_type = NO_CHECK_TYPE;
2876 end = F2FS_I_SB(inode)->max_file_blocks;
2877
2878 while (map.m_lblk < end) {
2879 map.m_len = end - map.m_lblk;
2880
b2532c69 2881 down_write(&fi->i_gc_rwsem[WRITE]);
c4020b2d 2882 err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
b2532c69 2883 up_write(&fi->i_gc_rwsem[WRITE]);
c4020b2d
CY		 2884 if (err)
2885 return err;
2886
2887 map.m_lblk = m_next_extent;
2888 }
2889
2890 return err;
2891}
2892
2893static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
2894{
2895 return f2fs_precache_extents(file_inode(filp));
2896}
2897
52656e6c
JK		 2898long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
2899{
1f227a3e
JK		 2900 if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
2901 return -EIO;
2902
52656e6c
JK		 2903 switch (cmd) {
2904 case F2FS_IOC_GETFLAGS:
2905 return f2fs_ioc_getflags(filp, arg);
2906 case F2FS_IOC_SETFLAGS:
2907 return f2fs_ioc_setflags(filp, arg);
d49f3e89
CY		 2908 case F2FS_IOC_GETVERSION:
2909 return f2fs_ioc_getversion(filp, arg);
88b88a66
JK		 2910 case F2FS_IOC_START_ATOMIC_WRITE:
2911 return f2fs_ioc_start_atomic_write(filp);
2912 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
2913 return f2fs_ioc_commit_atomic_write(filp);
02a1335f
JK		 2914 case F2FS_IOC_START_VOLATILE_WRITE:
2915 return f2fs_ioc_start_volatile_write(filp);
1e84371f
JK		 2916 case F2FS_IOC_RELEASE_VOLATILE_WRITE:
2917 return f2fs_ioc_release_volatile_write(filp);
2918 case F2FS_IOC_ABORT_VOLATILE_WRITE:
2919 return f2fs_ioc_abort_volatile_write(filp);
1abff93d
JK		 2920 case F2FS_IOC_SHUTDOWN:
2921 return f2fs_ioc_shutdown(filp, arg);
52656e6c
JK		 2922 case FITRIM:
2923 return f2fs_ioc_fitrim(filp, arg);
f424f664
JK		 2924 case F2FS_IOC_SET_ENCRYPTION_POLICY:
2925 return f2fs_ioc_set_encryption_policy(filp, arg);
2926 case F2FS_IOC_GET_ENCRYPTION_POLICY:
2927 return f2fs_ioc_get_encryption_policy(filp, arg);
2928 case F2FS_IOC_GET_ENCRYPTION_PWSALT:
2929 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
c1c1b583
CY		 2930 case F2FS_IOC_GARBAGE_COLLECT:
2931 return f2fs_ioc_gc(filp, arg);
34dc77ad
JK		 2932 case F2FS_IOC_GARBAGE_COLLECT_RANGE:
2933 return f2fs_ioc_gc_range(filp, arg);
456b88e4 2934 case F2FS_IOC_WRITE_CHECKPOINT:
059c0648 2935 return f2fs_ioc_write_checkpoint(filp, arg);
d323d005
CY		 2936 case F2FS_IOC_DEFRAGMENT:
2937 return f2fs_ioc_defragment(filp, arg);
4dd6f977
JK		 2938 case F2FS_IOC_MOVE_RANGE:
2939 return f2fs_ioc_move_range(filp, arg);
e066b83c
JK		 2940 case F2FS_IOC_FLUSH_DEVICE:
2941 return f2fs_ioc_flush_device(filp, arg);
e65ef207
JK		 2942 case F2FS_IOC_GET_FEATURES:
2943 return f2fs_ioc_get_features(filp, arg);
2c1d0305
CY		 2944 case F2FS_IOC_FSGETXATTR:
2945 return f2fs_ioc_fsgetxattr(filp, arg);
2946 case F2FS_IOC_FSSETXATTR:
2947 return f2fs_ioc_fssetxattr(filp, arg);
1ad71a27
JK		 2948 case F2FS_IOC_GET_PIN_FILE:
2949 return f2fs_ioc_get_pin_file(filp, arg);
2950 case F2FS_IOC_SET_PIN_FILE:
2951 return f2fs_ioc_set_pin_file(filp, arg);
c4020b2d
CY		 2952 case F2FS_IOC_PRECACHE_EXTENTS:
2953 return f2fs_ioc_precache_extents(filp, arg);
fbfa2cc5
JK		 2954 default:
2955 return -ENOTTY;
2956 }
2957}
2958
fcc85a4d
JK		 2959static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2960{
b439b103
JK		 2961 struct file *file = iocb->ki_filp;
2962 struct inode *inode = file_inode(file);
2963 ssize_t ret;
fcc85a4d 2964
1f227a3e
JK		 2965 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
2966 return -EIO;
2967
b91050a8
HL		 2968 if ((iocb->ki_flags & IOCB_NOWAIT) && !(iocb->ki_flags & IOCB_DIRECT))
2969 return -EINVAL;
2970
2971 if (!inode_trylock(inode)) {
2972 if (iocb->ki_flags & IOCB_NOWAIT)
2973 return -EAGAIN;
2974 inode_lock(inode);
2975 }
2976
b439b103
JK		 2977 ret = generic_write_checks(iocb, from);
2978 if (ret > 0) {
dc7a10dd
JK		 2979 bool preallocated = false;
2980 size_t target_size = 0;
dc91de78 2981 int err;
a7de6086 2982
dc91de78
JK		 2983 if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
2984 set_inode_flag(inode, FI_NO_PREALLOC);
a7de6086 2985
b91050a8
HL		 2986 if ((iocb->ki_flags & IOCB_NOWAIT) &&
2987 (iocb->ki_flags & IOCB_DIRECT)) {
2988 if (!f2fs_overwrite_io(inode, iocb->ki_pos,
2989 iov_iter_count(from)) ||
2990 f2fs_has_inline_data(inode) ||
2991 f2fs_force_buffered_io(inode, WRITE)) {
cba41be0
YH		 2992 clear_inode_flag(inode,
2993 FI_NO_PREALLOC);
b91050a8
HL		 2994 inode_unlock(inode);
2995 return -EAGAIN;
2996 }
2997
2998 } else {
dc7a10dd
JK		 2999 preallocated = true;
3000 target_size = iocb->ki_pos + iov_iter_count(from);
3001
b91050a8
HL		 3002 err = f2fs_preallocate_blocks(iocb, from);
3003 if (err) {
3004 clear_inode_flag(inode, FI_NO_PREALLOC);
3005 inode_unlock(inode);
3006 return err;
3007 }
9dfa1baf 3008 }
a7de6086 3009 ret = __generic_file_write_iter(iocb, from);
dc91de78 3010 clear_inode_flag(inode, FI_NO_PREALLOC);
b0af6d49 3011
dc7a10dd
JK		 3012 /* if we couldn't write data, we should deallocate blocks. */
3013 if (preallocated && i_size_read(inode) < target_size)
3014 f2fs_truncate(inode);
3015
b0af6d49
CY		 3016 if (ret > 0)
3017 f2fs_update_iostat(F2FS_I_SB(inode), APP_WRITE_IO, ret);
b439b103
JK		 3018 }
3019 inode_unlock(inode);
3020
e2592217
CH		 3021 if (ret > 0)
3022 ret = generic_write_sync(iocb, ret);
b439b103 3023 return ret;
fcc85a4d
JK		 3024}
3025
e9750824
NJ		 3026#ifdef CONFIG_COMPAT
3027long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3028{
3029 switch (cmd) {
3030 case F2FS_IOC32_GETFLAGS:
3031 cmd = F2FS_IOC_GETFLAGS;
3032 break;
3033 case F2FS_IOC32_SETFLAGS:
3034 cmd = F2FS_IOC_SETFLAGS;
3035 break;
04ef4b62
CY		 3036 case F2FS_IOC32_GETVERSION:
3037 cmd = F2FS_IOC_GETVERSION;
3038 break;
3039 case F2FS_IOC_START_ATOMIC_WRITE:
3040 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
3041 case F2FS_IOC_START_VOLATILE_WRITE:
3042 case F2FS_IOC_RELEASE_VOLATILE_WRITE:
3043 case F2FS_IOC_ABORT_VOLATILE_WRITE:
3044 case F2FS_IOC_SHUTDOWN:
3045 case F2FS_IOC_SET_ENCRYPTION_POLICY:
3046 case F2FS_IOC_GET_ENCRYPTION_PWSALT:
3047 case F2FS_IOC_GET_ENCRYPTION_POLICY:
3048 case F2FS_IOC_GARBAGE_COLLECT:
34dc77ad 3049 case F2FS_IOC_GARBAGE_COLLECT_RANGE:
04ef4b62
CY		 3050 case F2FS_IOC_WRITE_CHECKPOINT:
3051 case F2FS_IOC_DEFRAGMENT:
4dd6f977 3052 case F2FS_IOC_MOVE_RANGE:
e066b83c 3053 case F2FS_IOC_FLUSH_DEVICE:
e65ef207 3054 case F2FS_IOC_GET_FEATURES:
2c1d0305
CY		 3055 case F2FS_IOC_FSGETXATTR:
3056 case F2FS_IOC_FSSETXATTR:
1ad71a27
JK		 3057 case F2FS_IOC_GET_PIN_FILE:
3058 case F2FS_IOC_SET_PIN_FILE:
c4020b2d 3059 case F2FS_IOC_PRECACHE_EXTENTS:
4dd6f977 3060 break;
e9750824
NJ		 3061 default:
3062 return -ENOIOCTLCMD;
3063 }
3064 return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
3065}
3066#endif
3067
fbfa2cc5 3068const struct file_operations f2fs_file_operations = {
267378d4 3069 .llseek = f2fs_llseek,
aad4f8bb 3070 .read_iter = generic_file_read_iter,
fcc85a4d
JK		 3071 .write_iter = f2fs_file_write_iter,
3072 .open = f2fs_file_open,
12662234 3073 .release = f2fs_release_file,
fbfa2cc5 3074 .mmap = f2fs_file_mmap,
7a10f017 3075 .flush = f2fs_file_flush,
fbfa2cc5
JK		 3076 .fsync = f2fs_sync_file,
3077 .fallocate = f2fs_fallocate,
3078 .unlocked_ioctl = f2fs_ioctl,
e9750824
NJ		 3079#ifdef CONFIG_COMPAT
3080 .compat_ioctl = f2fs_compat_ioctl,
3081#endif
fbfa2cc5 3082 .splice_read = generic_file_splice_read,
8d020765 3083 .splice_write = iter_file_splice_write,
fbfa2cc5 3084};
Linux 6.x block layer and io_uring tree(s)