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