file.c (8df22a4d6f5b81c9c1703579d4907b57002689ed) file.c (88b88a66797159949cec32eaab12b4968f6fae2d)
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

--- 19 unchanged lines hidden (view full) ---

28#include "acl.h"
29#include <trace/events/f2fs.h>
30
31static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
32 struct vm_fault *vmf)
33{
34 struct page *page = vmf->page;
35 struct inode *inode = file_inode(vma->vm_file);
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

--- 19 unchanged lines hidden (view full) ---

28#include "acl.h"
29#include <trace/events/f2fs.h>
30
31static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
32 struct vm_fault *vmf)
33{
34 struct page *page = vmf->page;
35 struct inode *inode = file_inode(vma->vm_file);
36 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
36 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
37 struct dnode_of_data dn;
38 int err;
39
40 f2fs_balance_fs(sbi);
41
42 sb_start_pagefault(inode->i_sb);
43
44 /* force to convert with normal data indices */

--- 67 unchanged lines hidden (view full) ---

112
113 *pino = parent_ino(dentry);
114 dput(dentry);
115 return 1;
116}
117
118static inline bool need_do_checkpoint(struct inode *inode)
119{
37 struct dnode_of_data dn;
38 int err;
39
40 f2fs_balance_fs(sbi);
41
42 sb_start_pagefault(inode->i_sb);
43
44 /* force to convert with normal data indices */

--- 67 unchanged lines hidden (view full) ---

112
113 *pino = parent_ino(dentry);
114 dput(dentry);
115 return 1;
116}
117
118static inline bool need_do_checkpoint(struct inode *inode)
119{
120 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
120 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
121 bool need_cp = false;
122
123 if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
124 need_cp = true;
125 else if (file_wrong_pino(inode))
126 need_cp = true;
127 else if (!space_for_roll_forward(sbi))
128 need_cp = true;

--- 4 unchanged lines hidden (view full) ---

133
134 return need_cp;
135}
136
137int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
138{
139 struct inode *inode = file->f_mapping->host;
140 struct f2fs_inode_info *fi = F2FS_I(inode);
121 bool need_cp = false;
122
123 if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
124 need_cp = true;
125 else if (file_wrong_pino(inode))
126 need_cp = true;
127 else if (!space_for_roll_forward(sbi))
128 need_cp = true;

--- 4 unchanged lines hidden (view full) ---

133
134 return need_cp;
135}
136
137int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
138{
139 struct inode *inode = file->f_mapping->host;
140 struct f2fs_inode_info *fi = F2FS_I(inode);
141 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
141 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
142 nid_t ino = inode->i_ino;
142 int ret = 0;
143 bool need_cp = false;
144 struct writeback_control wbc = {
145 .sync_mode = WB_SYNC_ALL,
146 .nr_to_write = LONG_MAX,
147 .for_reclaim = 0,
148 };
149
150 if (unlikely(f2fs_readonly(inode->i_sb)))
151 return 0;
152
153 trace_f2fs_sync_file_enter(inode);
154
155 /* if fdatasync is triggered, let's do in-place-update */
143 int ret = 0;
144 bool need_cp = false;
145 struct writeback_control wbc = {
146 .sync_mode = WB_SYNC_ALL,
147 .nr_to_write = LONG_MAX,
148 .for_reclaim = 0,
149 };
150
151 if (unlikely(f2fs_readonly(inode->i_sb)))
152 return 0;
153
154 trace_f2fs_sync_file_enter(inode);
155
156 /* if fdatasync is triggered, let's do in-place-update */
156 if (datasync)
157 if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
157 set_inode_flag(fi, FI_NEED_IPU);
158 set_inode_flag(fi, FI_NEED_IPU);
158
159 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
159 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
160 if (datasync)
161 clear_inode_flag(fi, FI_NEED_IPU);
160 clear_inode_flag(fi, FI_NEED_IPU);
161
162 if (ret) {
163 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
164 return ret;
165 }
166
167 /*
168 * if there is no written data, don't waste time to write recovery info.
169 */
170 if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
162 if (ret) {
163 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
164 return ret;
165 }
166
167 /*
168 * if there is no written data, don't waste time to write recovery info.
169 */
170 if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
171 !exist_written_data(sbi, inode->i_ino, APPEND_INO)) {
171 !exist_written_data(sbi, ino, APPEND_INO)) {
172 struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
173
174 /* But we need to avoid that there are some inode updates */
175 if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino)) {
176 f2fs_put_page(i, 0);
177 goto go_write;
178 }
179 f2fs_put_page(i, 0);
180
172 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
181 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
173 exist_written_data(sbi, inode->i_ino, UPDATE_INO))
182 exist_written_data(sbi, ino, UPDATE_INO))
174 goto flush_out;
175 goto out;
176 }
183 goto flush_out;
184 goto out;
185 }
177
186go_write:
178 /* guarantee free sections for fsync */
179 f2fs_balance_fs(sbi);
180
181 /*
182 * Both of fdatasync() and fsync() are able to be recovered from
183 * sudden-power-off.
184 */
185 down_read(&fi->i_sem);

--- 16 unchanged lines hidden (view full) ---

202 mark_inode_dirty_sync(inode);
203 ret = f2fs_write_inode(inode, NULL);
204 if (ret)
205 goto out;
206 } else {
207 up_write(&fi->i_sem);
208 }
209 } else {
187 /* guarantee free sections for fsync */
188 f2fs_balance_fs(sbi);
189
190 /*
191 * Both of fdatasync() and fsync() are able to be recovered from
192 * sudden-power-off.
193 */
194 down_read(&fi->i_sem);

--- 16 unchanged lines hidden (view full) ---

211 mark_inode_dirty_sync(inode);
212 ret = f2fs_write_inode(inode, NULL);
213 if (ret)
214 goto out;
215 } else {
216 up_write(&fi->i_sem);
217 }
218 } else {
210 /* if there is no written node page, write its inode page */
211 while (!sync_node_pages(sbi, inode->i_ino, &wbc)) {
212 if (fsync_mark_done(sbi, inode->i_ino))
213 goto out;
219sync_nodes:
220 sync_node_pages(sbi, ino, &wbc);
221
222 if (need_inode_block_update(sbi, ino)) {
214 mark_inode_dirty_sync(inode);
215 ret = f2fs_write_inode(inode, NULL);
216 if (ret)
217 goto out;
223 mark_inode_dirty_sync(inode);
224 ret = f2fs_write_inode(inode, NULL);
225 if (ret)
226 goto out;
227 goto sync_nodes;
218 }
228 }
219 ret = wait_on_node_pages_writeback(sbi, inode->i_ino);
229
230 ret = wait_on_node_pages_writeback(sbi, ino);
220 if (ret)
221 goto out;
222
223 /* once recovery info is written, don't need to tack this */
231 if (ret)
232 goto out;
233
234 /* once recovery info is written, don't need to tack this */
224 remove_dirty_inode(sbi, inode->i_ino, APPEND_INO);
235 remove_dirty_inode(sbi, ino, APPEND_INO);
225 clear_inode_flag(fi, FI_APPEND_WRITE);
226flush_out:
236 clear_inode_flag(fi, FI_APPEND_WRITE);
237flush_out:
227 remove_dirty_inode(sbi, inode->i_ino, UPDATE_INO);
238 remove_dirty_inode(sbi, ino, UPDATE_INO);
228 clear_inode_flag(fi, FI_UPDATE_WRITE);
239 clear_inode_flag(fi, FI_UPDATE_WRITE);
229 ret = f2fs_issue_flush(F2FS_SB(inode->i_sb));
240 ret = f2fs_issue_flush(F2FS_I_SB(inode));
230 }
231out:
232 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
233 return ret;
234}
235
236static pgoff_t __get_first_dirty_index(struct address_space *mapping,
237 pgoff_t pgofs, int whence)

--- 110 unchanged lines hidden (view full) ---

348 switch (whence) {
349 case SEEK_SET:
350 case SEEK_CUR:
351 case SEEK_END:
352 return generic_file_llseek_size(file, offset, whence,
353 maxbytes, i_size_read(inode));
354 case SEEK_DATA:
355 case SEEK_HOLE:
241 }
242out:
243 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
244 return ret;
245}
246
247static pgoff_t __get_first_dirty_index(struct address_space *mapping,
248 pgoff_t pgofs, int whence)

--- 110 unchanged lines hidden (view full) ---

359 switch (whence) {
360 case SEEK_SET:
361 case SEEK_CUR:
362 case SEEK_END:
363 return generic_file_llseek_size(file, offset, whence,
364 maxbytes, i_size_read(inode));
365 case SEEK_DATA:
366 case SEEK_HOLE:
367 if (offset < 0)
368 return -ENXIO;
356 return f2fs_seek_block(file, offset, whence);
357 }
358
359 return -EINVAL;
360}
361
362static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
363{
364 file_accessed(file);
365 vma->vm_ops = &f2fs_file_vm_ops;
366 return 0;
367}
368
369int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
370{
371 int nr_free = 0, ofs = dn->ofs_in_node;
369 return f2fs_seek_block(file, offset, whence);
370 }
371
372 return -EINVAL;
373}
374
375static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
376{
377 file_accessed(file);
378 vma->vm_ops = &f2fs_file_vm_ops;
379 return 0;
380}
381
382int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
383{
384 int nr_free = 0, ofs = dn->ofs_in_node;
372 struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
385 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
373 struct f2fs_node *raw_node;
374 __le32 *addr;
375
376 raw_node = F2FS_NODE(dn->node_page);
377 addr = blkaddr_in_node(raw_node) + ofs;
378
379 for (; count > 0; count--, addr++, dn->ofs_in_node++) {
380 block_t blkaddr = le32_to_cpu(*addr);

--- 46 unchanged lines hidden (view full) ---

427 set_page_dirty(page);
428
429out:
430 f2fs_put_page(page, 1);
431}
432
433int truncate_blocks(struct inode *inode, u64 from, bool lock)
434{
386 struct f2fs_node *raw_node;
387 __le32 *addr;
388
389 raw_node = F2FS_NODE(dn->node_page);
390 addr = blkaddr_in_node(raw_node) + ofs;
391
392 for (; count > 0; count--, addr++, dn->ofs_in_node++) {
393 block_t blkaddr = le32_to_cpu(*addr);

--- 46 unchanged lines hidden (view full) ---

440 set_page_dirty(page);
441
442out:
443 f2fs_put_page(page, 1);
444}
445
446int truncate_blocks(struct inode *inode, u64 from, bool lock)
447{
435 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
448 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
436 unsigned int blocksize = inode->i_sb->s_blocksize;
437 struct dnode_of_data dn;
438 pgoff_t free_from;
439 int count = 0, err = 0;
440
441 trace_f2fs_truncate_blocks_enter(inode, from);
442
443 if (f2fs_has_inline_data(inode))

--- 14 unchanged lines hidden (view full) ---

458 f2fs_unlock_op(sbi);
459 trace_f2fs_truncate_blocks_exit(inode, err);
460 return err;
461 }
462
463 count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
464
465 count -= dn.ofs_in_node;
449 unsigned int blocksize = inode->i_sb->s_blocksize;
450 struct dnode_of_data dn;
451 pgoff_t free_from;
452 int count = 0, err = 0;
453
454 trace_f2fs_truncate_blocks_enter(inode, from);
455
456 if (f2fs_has_inline_data(inode))

--- 14 unchanged lines hidden (view full) ---

471 f2fs_unlock_op(sbi);
472 trace_f2fs_truncate_blocks_exit(inode, err);
473 return err;
474 }
475
476 count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
477
478 count -= dn.ofs_in_node;
466 f2fs_bug_on(count < 0);
479 f2fs_bug_on(sbi, count < 0);
467
468 if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
469 truncate_data_blocks_range(&dn, count);
470 free_from += count;
471 }
472
473 f2fs_put_dnode(&dn);
474free_next:

--- 67 unchanged lines hidden (view full) ---

542 struct inode *inode = dentry->d_inode;
543 struct f2fs_inode_info *fi = F2FS_I(inode);
544 int err;
545
546 err = inode_change_ok(inode, attr);
547 if (err)
548 return err;
549
480
481 if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
482 truncate_data_blocks_range(&dn, count);
483 free_from += count;
484 }
485
486 f2fs_put_dnode(&dn);
487free_next:

--- 67 unchanged lines hidden (view full) ---

555 struct inode *inode = dentry->d_inode;
556 struct f2fs_inode_info *fi = F2FS_I(inode);
557 int err;
558
559 err = inode_change_ok(inode, attr);
560 if (err)
561 return err;
562
550 if ((attr->ia_valid & ATTR_SIZE) &&
551 attr->ia_size != i_size_read(inode)) {
563 if (attr->ia_valid & ATTR_SIZE) {
552 err = f2fs_convert_inline_data(inode, attr->ia_size, NULL);
553 if (err)
554 return err;
555
564 err = f2fs_convert_inline_data(inode, attr->ia_size, NULL);
565 if (err)
566 return err;
567
556 truncate_setsize(inode, attr->ia_size);
557 f2fs_truncate(inode);
558 f2fs_balance_fs(F2FS_SB(inode->i_sb));
568 if (attr->ia_size != i_size_read(inode)) {
569 truncate_setsize(inode, attr->ia_size);
570 f2fs_truncate(inode);
571 f2fs_balance_fs(F2FS_I_SB(inode));
572 } else {
573 /*
574 * giving a chance to truncate blocks past EOF which
575 * are fallocated with FALLOC_FL_KEEP_SIZE.
576 */
577 f2fs_truncate(inode);
578 }
559 }
560
561 __setattr_copy(inode, attr);
562
563 if (attr->ia_valid & ATTR_MODE) {
564 err = posix_acl_chmod(inode, get_inode_mode(inode));
565 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
566 inode->i_mode = fi->i_acl_mode;

--- 17 unchanged lines hidden (view full) ---

584 .removexattr = generic_removexattr,
585#endif
586 .fiemap = f2fs_fiemap,
587};
588
589static void fill_zero(struct inode *inode, pgoff_t index,
590 loff_t start, loff_t len)
591{
579 }
580
581 __setattr_copy(inode, attr);
582
583 if (attr->ia_valid & ATTR_MODE) {
584 err = posix_acl_chmod(inode, get_inode_mode(inode));
585 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
586 inode->i_mode = fi->i_acl_mode;

--- 17 unchanged lines hidden (view full) ---

604 .removexattr = generic_removexattr,
605#endif
606 .fiemap = f2fs_fiemap,
607};
608
609static void fill_zero(struct inode *inode, pgoff_t index,
610 loff_t start, loff_t len)
611{
592 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
612 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
593 struct page *page;
594
595 if (!len)
596 return;
597
598 f2fs_balance_fs(sbi);
599
600 f2fs_lock_op(sbi);

--- 32 unchanged lines hidden (view full) ---

633}
634
635static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
636{
637 pgoff_t pg_start, pg_end;
638 loff_t off_start, off_end;
639 int ret = 0;
640
613 struct page *page;
614
615 if (!len)
616 return;
617
618 f2fs_balance_fs(sbi);
619
620 f2fs_lock_op(sbi);

--- 32 unchanged lines hidden (view full) ---

653}
654
655static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
656{
657 pgoff_t pg_start, pg_end;
658 loff_t off_start, off_end;
659 int ret = 0;
660
661 if (!S_ISREG(inode->i_mode))
662 return -EOPNOTSUPP;
663
664 /* skip punching hole beyond i_size */
665 if (offset >= inode->i_size)
666 return ret;
667
641 ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, NULL);
642 if (ret)
643 return ret;
644
645 pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
646 pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
647
648 off_start = offset & (PAGE_CACHE_SIZE - 1);

--- 7 unchanged lines hidden (view full) ---

656 fill_zero(inode, pg_start++, off_start,
657 PAGE_CACHE_SIZE - off_start);
658 if (off_end)
659 fill_zero(inode, pg_end, 0, off_end);
660
661 if (pg_start < pg_end) {
662 struct address_space *mapping = inode->i_mapping;
663 loff_t blk_start, blk_end;
668 ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, NULL);
669 if (ret)
670 return ret;
671
672 pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
673 pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
674
675 off_start = offset & (PAGE_CACHE_SIZE - 1);

--- 7 unchanged lines hidden (view full) ---

683 fill_zero(inode, pg_start++, off_start,
684 PAGE_CACHE_SIZE - off_start);
685 if (off_end)
686 fill_zero(inode, pg_end, 0, off_end);
687
688 if (pg_start < pg_end) {
689 struct address_space *mapping = inode->i_mapping;
690 loff_t blk_start, blk_end;
664 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
691 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
665
666 f2fs_balance_fs(sbi);
667
668 blk_start = pg_start << PAGE_CACHE_SHIFT;
669 blk_end = pg_end << PAGE_CACHE_SHIFT;
670 truncate_inode_pages_range(mapping, blk_start,
671 blk_end - 1);
672

--- 4 unchanged lines hidden (view full) ---

677 }
678
679 return ret;
680}
681
682static int expand_inode_data(struct inode *inode, loff_t offset,
683 loff_t len, int mode)
684{
692
693 f2fs_balance_fs(sbi);
694
695 blk_start = pg_start << PAGE_CACHE_SHIFT;
696 blk_end = pg_end << PAGE_CACHE_SHIFT;
697 truncate_inode_pages_range(mapping, blk_start,
698 blk_end - 1);
699

--- 4 unchanged lines hidden (view full) ---

704 }
705
706 return ret;
707}
708
709static int expand_inode_data(struct inode *inode, loff_t offset,
710 loff_t len, int mode)
711{
685 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
712 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
686 pgoff_t index, pg_start, pg_end;
687 loff_t new_size = i_size_read(inode);
688 loff_t off_start, off_end;
689 int ret = 0;
690
691 f2fs_balance_fs(sbi);
692
693 ret = inode_newsize_ok(inode, (len + offset));

--- 79 unchanged lines hidden (view full) ---

773 if (S_ISDIR(mode))
774 return flags;
775 else if (S_ISREG(mode))
776 return flags & F2FS_REG_FLMASK;
777 else
778 return flags & F2FS_OTHER_FLMASK;
779}
780
713 pgoff_t index, pg_start, pg_end;
714 loff_t new_size = i_size_read(inode);
715 loff_t off_start, off_end;
716 int ret = 0;
717
718 f2fs_balance_fs(sbi);
719
720 ret = inode_newsize_ok(inode, (len + offset));

--- 79 unchanged lines hidden (view full) ---

800 if (S_ISDIR(mode))
801 return flags;
802 else if (S_ISREG(mode))
803 return flags & F2FS_REG_FLMASK;
804 else
805 return flags & F2FS_OTHER_FLMASK;
806}
807
781long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
808static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
782{
783 struct inode *inode = file_inode(filp);
784 struct f2fs_inode_info *fi = F2FS_I(inode);
809{
810 struct inode *inode = file_inode(filp);
811 struct f2fs_inode_info *fi = F2FS_I(inode);
785 unsigned int flags;
812 unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
813 return put_user(flags, (int __user *)arg);
814}
815
816static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
817{
818 struct inode *inode = file_inode(filp);
819 struct f2fs_inode_info *fi = F2FS_I(inode);
820 unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
821 unsigned int oldflags;
786 int ret;
787
822 int ret;
823
788 switch (cmd) {
789 case F2FS_IOC_GETFLAGS:
790 flags = fi->i_flags & FS_FL_USER_VISIBLE;
791 return put_user(flags, (int __user *) arg);
792 case F2FS_IOC_SETFLAGS:
793 {
794 unsigned int oldflags;
824 ret = mnt_want_write_file(filp);
825 if (ret)
826 return ret;
795
827
796 ret = mnt_want_write_file(filp);
797 if (ret)
798 return ret;
828 if (!inode_owner_or_capable(inode)) {
829 ret = -EACCES;
830 goto out;
831 }
799
832
800 if (!inode_owner_or_capable(inode)) {
801 ret = -EACCES;
802 goto out;
803 }
833 if (get_user(flags, (int __user *)arg)) {
834 ret = -EFAULT;
835 goto out;
836 }
804
837
805 if (get_user(flags, (int __user *) arg)) {
806 ret = -EFAULT;
838 flags = f2fs_mask_flags(inode->i_mode, flags);
839
840 mutex_lock(&inode->i_mutex);
841
842 oldflags = fi->i_flags;
843
844 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
845 if (!capable(CAP_LINUX_IMMUTABLE)) {
846 mutex_unlock(&inode->i_mutex);
847 ret = -EPERM;
807 goto out;
808 }
848 goto out;
849 }
850 }
809
851
810 flags = f2fs_mask_flags(inode->i_mode, flags);
852 flags = flags & FS_FL_USER_MODIFIABLE;
853 flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
854 fi->i_flags = flags;
855 mutex_unlock(&inode->i_mutex);
811
856
812 mutex_lock(&inode->i_mutex);
857 f2fs_set_inode_flags(inode);
858 inode->i_ctime = CURRENT_TIME;
859 mark_inode_dirty(inode);
860out:
861 mnt_drop_write_file(filp);
862 return ret;
863}
813
864
814 oldflags = fi->i_flags;
865static int f2fs_ioc_start_atomic_write(struct file *filp)
866{
867 struct inode *inode = file_inode(filp);
868 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
815
869
816 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
817 if (!capable(CAP_LINUX_IMMUTABLE)) {
818 mutex_unlock(&inode->i_mutex);
819 ret = -EPERM;
820 goto out;
821 }
822 }
870 if (!inode_owner_or_capable(inode))
871 return -EACCES;
823
872
824 flags = flags & FS_FL_USER_MODIFIABLE;
825 flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
826 fi->i_flags = flags;
827 mutex_unlock(&inode->i_mutex);
873 f2fs_balance_fs(sbi);
828
874
829 f2fs_set_inode_flags(inode);
830 inode->i_ctime = CURRENT_TIME;
831 mark_inode_dirty(inode);
832out:
833 mnt_drop_write_file(filp);
875 set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
876
877 return f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, NULL);
878}
879
880static int f2fs_ioc_commit_atomic_write(struct file *filp)
881{
882 struct inode *inode = file_inode(filp);
883 int ret;
884
885 if (!inode_owner_or_capable(inode))
886 return -EACCES;
887
888 ret = mnt_want_write_file(filp);
889 if (ret)
834 return ret;
890 return ret;
835 }
891
892 if (f2fs_is_atomic_file(inode))
893 commit_inmem_pages(inode, false);
894
895 ret = f2fs_sync_file(filp, 0, LONG_MAX, 0);
896 mnt_drop_write_file(filp);
897 return ret;
898}
899
900static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
901{
902 struct inode *inode = file_inode(filp);
903 struct super_block *sb = inode->i_sb;
904 struct request_queue *q = bdev_get_queue(sb->s_bdev);
905 struct fstrim_range range;
906 int ret;
907
908 if (!capable(CAP_SYS_ADMIN))
909 return -EPERM;
910
911 if (!blk_queue_discard(q))
912 return -EOPNOTSUPP;
913
914 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
915 sizeof(range)))
916 return -EFAULT;
917
918 range.minlen = max((unsigned int)range.minlen,
919 q->limits.discard_granularity);
920 ret = f2fs_trim_fs(F2FS_SB(sb), &range);
921 if (ret < 0)
922 return ret;
923
924 if (copy_to_user((struct fstrim_range __user *)arg, &range,
925 sizeof(range)))
926 return -EFAULT;
927 return 0;
928}
929
930long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
931{
932 switch (cmd) {
933 case F2FS_IOC_GETFLAGS:
934 return f2fs_ioc_getflags(filp, arg);
935 case F2FS_IOC_SETFLAGS:
936 return f2fs_ioc_setflags(filp, arg);
937 case F2FS_IOC_START_ATOMIC_WRITE:
938 return f2fs_ioc_start_atomic_write(filp);
939 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
940 return f2fs_ioc_commit_atomic_write(filp);
941 case FITRIM:
942 return f2fs_ioc_fitrim(filp, arg);
836 default:
837 return -ENOTTY;
838 }
839}
840
841#ifdef CONFIG_COMPAT
842long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
843{

--- 31 unchanged lines hidden --- 		943 default:
944 return -ENOTTY;
945 }
946}
947
948#ifdef CONFIG_COMPAT
949long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
950{

--- 31 unchanged lines hidden ---