projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
f2fs crypto: add encryption policy and password salt support
[deliverable/linux.git] / fs / f2fs / file.c
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/random.h>
24
25 #include "f2fs.h"
26 #include "node.h"
27 #include "segment.h"
28 #include "xattr.h"
29 #include "acl.h"
30 #include "trace.h"
31 #include <trace/events/f2fs.h>
32
33 static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
34 struct vm_fault *vmf)
35 {
36 struct page *page = vmf->page;
37 struct inode *inode = file_inode(vma->vm_file);
38 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
39 struct dnode_of_data dn;
40 int err;
41
42 f2fs_balance_fs(sbi);
43
44 sb_start_pagefault(inode->i_sb);
45
46 f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
47
48 /* block allocation */
49 f2fs_lock_op(sbi);
50 set_new_dnode(&dn, inode, NULL, NULL, 0);
51 err = f2fs_reserve_block(&dn, page->index);
52 if (err) {
53 f2fs_unlock_op(sbi);
54 goto out;
55 }
56 f2fs_put_dnode(&dn);
57 f2fs_unlock_op(sbi);
58
59 file_update_time(vma->vm_file);
60 lock_page(page);
61 if (unlikely(page->mapping != inode->i_mapping ||
62 page_offset(page) > i_size_read(inode) ||
63 !PageUptodate(page))) {
64 unlock_page(page);
65 err = -EFAULT;
66 goto out;
67 }
68
69 /*
70 * check to see if the page is mapped already (no holes)
71 */
72 if (PageMappedToDisk(page))
73 goto mapped;
74
75 /* page is wholly or partially inside EOF */
76 if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) {
77 unsigned offset;
78 offset = i_size_read(inode) & ~PAGE_CACHE_MASK;
79 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
80 }
81 set_page_dirty(page);
82 SetPageUptodate(page);
83
84 trace_f2fs_vm_page_mkwrite(page, DATA);
85 mapped:
86 /* fill the page */
87 f2fs_wait_on_page_writeback(page, DATA);
88 out:
89 sb_end_pagefault(inode->i_sb);
90 return block_page_mkwrite_return(err);
91 }
92
93 static const struct vm_operations_struct f2fs_file_vm_ops = {
94 .fault = filemap_fault,
95 .map_pages = filemap_map_pages,
96 .page_mkwrite = f2fs_vm_page_mkwrite,
97 };
98
99 static int get_parent_ino(struct inode *inode, nid_t *pino)
100 {
101 struct dentry *dentry;
102
103 inode = igrab(inode);
104 dentry = d_find_any_alias(inode);
105 iput(inode);
106 if (!dentry)
107 return 0;
108
109 if (update_dent_inode(inode, &dentry->d_name)) {
110 dput(dentry);
111 return 0;
112 }
113
114 *pino = parent_ino(dentry);
115 dput(dentry);
116 return 1;
117 }
118
119 static inline bool need_do_checkpoint(struct inode *inode)
120 {
121 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
122 bool need_cp = false;
123
124 if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
125 need_cp = true;
126 else if (file_wrong_pino(inode))
127 need_cp = true;
128 else if (!space_for_roll_forward(sbi))
129 need_cp = true;
130 else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino))
131 need_cp = true;
132 else if (F2FS_I(inode)->xattr_ver == cur_cp_version(F2FS_CKPT(sbi)))
133 need_cp = true;
134 else if (test_opt(sbi, FASTBOOT))
135 need_cp = true;
136 else if (sbi->active_logs == 2)
137 need_cp = true;
138
139 return need_cp;
140 }
141
142 static bool need_inode_page_update(struct f2fs_sb_info *sbi, nid_t ino)
143 {
144 struct page *i = find_get_page(NODE_MAPPING(sbi), ino);
145 bool ret = false;
146 /* But we need to avoid that there are some inode updates */
147 if ((i && PageDirty(i)) || need_inode_block_update(sbi, ino))
148 ret = true;
149 f2fs_put_page(i, 0);
150 return ret;
151 }
152
153 static void try_to_fix_pino(struct inode *inode)
154 {
155 struct f2fs_inode_info *fi = F2FS_I(inode);
156 nid_t pino;
157
158 down_write(&fi->i_sem);
159 fi->xattr_ver = 0;
160 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
161 get_parent_ino(inode, &pino)) {
162 fi->i_pino = pino;
163 file_got_pino(inode);
164 up_write(&fi->i_sem);
165
166 mark_inode_dirty_sync(inode);
167 f2fs_write_inode(inode, NULL);
168 } else {
169 up_write(&fi->i_sem);
170 }
171 }
172
173 int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
174 {
175 struct inode *inode = file->f_mapping->host;
176 struct f2fs_inode_info *fi = F2FS_I(inode);
177 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
178 nid_t ino = inode->i_ino;
179 int ret = 0;
180 bool need_cp = false;
181 struct writeback_control wbc = {
182 .sync_mode = WB_SYNC_ALL,
183 .nr_to_write = LONG_MAX,
184 .for_reclaim = 0,
185 };
186
187 if (unlikely(f2fs_readonly(inode->i_sb)))
188 return 0;
189
190 trace_f2fs_sync_file_enter(inode);
191
192 /* if fdatasync is triggered, let's do in-place-update */
193 if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
194 set_inode_flag(fi, FI_NEED_IPU);
195 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
196 clear_inode_flag(fi, FI_NEED_IPU);
197
198 if (ret) {
199 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
200 return ret;
201 }
202
203 /* if the inode is dirty, let's recover all the time */
204 if (!datasync && is_inode_flag_set(fi, FI_DIRTY_INODE)) {
205 update_inode_page(inode);
206 goto go_write;
207 }
208
209 /*
210 * if there is no written data, don't waste time to write recovery info.
211 */
212 if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
213 !exist_written_data(sbi, ino, APPEND_INO)) {
214
215 /* it may call write_inode just prior to fsync */
216 if (need_inode_page_update(sbi, ino))
217 goto go_write;
218
219 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
220 exist_written_data(sbi, ino, UPDATE_INO))
221 goto flush_out;
222 goto out;
223 }
224 go_write:
225 /* guarantee free sections for fsync */
226 f2fs_balance_fs(sbi);
227
228 /*
229 * Both of fdatasync() and fsync() are able to be recovered from
230 * sudden-power-off.
231 */
232 down_read(&fi->i_sem);
233 need_cp = need_do_checkpoint(inode);
234 up_read(&fi->i_sem);
235
236 if (need_cp) {
237 /* all the dirty node pages should be flushed for POR */
238 ret = f2fs_sync_fs(inode->i_sb, 1);
239
240 /*
241 * We've secured consistency through sync_fs. Following pino
242 * will be used only for fsynced inodes after checkpoint.
243 */
244 try_to_fix_pino(inode);
245 clear_inode_flag(fi, FI_APPEND_WRITE);
246 clear_inode_flag(fi, FI_UPDATE_WRITE);
247 goto out;
248 }
249 sync_nodes:
250 sync_node_pages(sbi, ino, &wbc);
251
252 /* if cp_error was enabled, we should avoid infinite loop */
253 if (unlikely(f2fs_cp_error(sbi)))
254 goto out;
255
256 if (need_inode_block_update(sbi, ino)) {
257 mark_inode_dirty_sync(inode);
258 f2fs_write_inode(inode, NULL);
259 goto sync_nodes;
260 }
261
262 ret = wait_on_node_pages_writeback(sbi, ino);
263 if (ret)
264 goto out;
265
266 /* once recovery info is written, don't need to tack this */
267 remove_dirty_inode(sbi, ino, APPEND_INO);
268 clear_inode_flag(fi, FI_APPEND_WRITE);
269 flush_out:
270 remove_dirty_inode(sbi, ino, UPDATE_INO);
271 clear_inode_flag(fi, FI_UPDATE_WRITE);
272 ret = f2fs_issue_flush(sbi);
273 out:
274 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
275 f2fs_trace_ios(NULL, 1);
276 return ret;
277 }
278
279 static pgoff_t __get_first_dirty_index(struct address_space *mapping,
280 pgoff_t pgofs, int whence)
281 {
282 struct pagevec pvec;
283 int nr_pages;
284
285 if (whence != SEEK_DATA)
286 return 0;
287
288 /* find first dirty page index */
289 pagevec_init(&pvec, 0);
290 nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
291 PAGECACHE_TAG_DIRTY, 1);
292 pgofs = nr_pages ? pvec.pages[0]->index : LONG_MAX;
293 pagevec_release(&pvec);
294 return pgofs;
295 }
296
297 static bool __found_offset(block_t blkaddr, pgoff_t dirty, pgoff_t pgofs,
298 int whence)
299 {
300 switch (whence) {
301 case SEEK_DATA:
302 if ((blkaddr == NEW_ADDR && dirty == pgofs) ||
303 (blkaddr != NEW_ADDR && blkaddr != NULL_ADDR))
304 return true;
305 break;
306 case SEEK_HOLE:
307 if (blkaddr == NULL_ADDR)
308 return true;
309 break;
310 }
311 return false;
312 }
313
314 static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
315 {
316 struct inode *inode = file->f_mapping->host;
317 loff_t maxbytes = inode->i_sb->s_maxbytes;
318 struct dnode_of_data dn;
319 pgoff_t pgofs, end_offset, dirty;
320 loff_t data_ofs = offset;
321 loff_t isize;
322 int err = 0;
323
324 mutex_lock(&inode->i_mutex);
325
326 isize = i_size_read(inode);
327 if (offset >= isize)
328 goto fail;
329
330 /* handle inline data case */
331 if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
332 if (whence == SEEK_HOLE)
333 data_ofs = isize;
334 goto found;
335 }
336
337 pgofs = (pgoff_t)(offset >> PAGE_CACHE_SHIFT);
338
339 dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
340
341 for (; data_ofs < isize; data_ofs = pgofs << PAGE_CACHE_SHIFT) {
342 set_new_dnode(&dn, inode, NULL, NULL, 0);
343 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA);
344 if (err && err != -ENOENT) {
345 goto fail;
346 } else if (err == -ENOENT) {
347 /* direct node does not exists */
348 if (whence == SEEK_DATA) {
349 pgofs = PGOFS_OF_NEXT_DNODE(pgofs,
350 F2FS_I(inode));
351 continue;
352 } else {
353 goto found;
354 }
355 }
356
357 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
358
359 /* find data/hole in dnode block */
360 for (; dn.ofs_in_node < end_offset;
361 dn.ofs_in_node++, pgofs++,
362 data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
363 block_t blkaddr;
364 blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
365
366 if (__found_offset(blkaddr, dirty, pgofs, whence)) {
367 f2fs_put_dnode(&dn);
368 goto found;
369 }
370 }
371 f2fs_put_dnode(&dn);
372 }
373
374 if (whence == SEEK_DATA)
375 goto fail;
376 found:
377 if (whence == SEEK_HOLE && data_ofs > isize)
378 data_ofs = isize;
379 mutex_unlock(&inode->i_mutex);
380 return vfs_setpos(file, data_ofs, maxbytes);
381 fail:
382 mutex_unlock(&inode->i_mutex);
383 return -ENXIO;
384 }
385
386 static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
387 {
388 struct inode *inode = file->f_mapping->host;
389 loff_t maxbytes = inode->i_sb->s_maxbytes;
390
391 switch (whence) {
392 case SEEK_SET:
393 case SEEK_CUR:
394 case SEEK_END:
395 return generic_file_llseek_size(file, offset, whence,
396 maxbytes, i_size_read(inode));
397 case SEEK_DATA:
398 case SEEK_HOLE:
399 if (offset < 0)
400 return -ENXIO;
401 return f2fs_seek_block(file, offset, whence);
402 }
403
404 return -EINVAL;
405 }
406
407 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
408 {
409 struct inode *inode = file_inode(file);
410
411 /* we don't need to use inline_data strictly */
412 if (f2fs_has_inline_data(inode)) {
413 int err = f2fs_convert_inline_inode(inode);
414 if (err)
415 return err;
416 }
417
418 file_accessed(file);
419 vma->vm_ops = &f2fs_file_vm_ops;
420 return 0;
421 }
422
423 int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
424 {
425 int nr_free = 0, ofs = dn->ofs_in_node;
426 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
427 struct f2fs_node *raw_node;
428 __le32 *addr;
429
430 raw_node = F2FS_NODE(dn->node_page);
431 addr = blkaddr_in_node(raw_node) + ofs;
432
433 for (; count > 0; count--, addr++, dn->ofs_in_node++) {
434 block_t blkaddr = le32_to_cpu(*addr);
435 if (blkaddr == NULL_ADDR)
436 continue;
437
438 dn->data_blkaddr = NULL_ADDR;
439 set_data_blkaddr(dn);
440 f2fs_update_extent_cache(dn);
441 invalidate_blocks(sbi, blkaddr);
442 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
443 clear_inode_flag(F2FS_I(dn->inode),
444 FI_FIRST_BLOCK_WRITTEN);
445 nr_free++;
446 }
447 if (nr_free) {
448 dec_valid_block_count(sbi, dn->inode, nr_free);
449 set_page_dirty(dn->node_page);
450 sync_inode_page(dn);
451 }
452 dn->ofs_in_node = ofs;
453
454 trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
455 dn->ofs_in_node, nr_free);
456 return nr_free;
457 }
458
459 void truncate_data_blocks(struct dnode_of_data *dn)
460 {
461 truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
462 }
463
464 static int truncate_partial_data_page(struct inode *inode, u64 from,
465 bool cache_only)
466 {
467 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
468 pgoff_t index = from >> PAGE_CACHE_SHIFT;
469 struct address_space *mapping = inode->i_mapping;
470 struct page *page;
471
472 if (!offset && !cache_only)
473 return 0;
474
475 if (cache_only) {
476 page = grab_cache_page(mapping, index);
477 if (page && PageUptodate(page))
478 goto truncate_out;
479 f2fs_put_page(page, 1);
480 return 0;
481 }
482
483 page = get_lock_data_page(inode, index);
484 if (IS_ERR(page))
485 return 0;
486 truncate_out:
487 f2fs_wait_on_page_writeback(page, DATA);
488 zero_user(page, offset, PAGE_CACHE_SIZE - offset);
489 if (!cache_only)
490 set_page_dirty(page);
491 f2fs_put_page(page, 1);
492 return 0;
493 }
494
495 int truncate_blocks(struct inode *inode, u64 from, bool lock)
496 {
497 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
498 unsigned int blocksize = inode->i_sb->s_blocksize;
499 struct dnode_of_data dn;
500 pgoff_t free_from;
501 int count = 0, err = 0;
502 struct page *ipage;
503 bool truncate_page = false;
504
505 trace_f2fs_truncate_blocks_enter(inode, from);
506
507 free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
508
509 if (lock)
510 f2fs_lock_op(sbi);
511
512 ipage = get_node_page(sbi, inode->i_ino);
513 if (IS_ERR(ipage)) {
514 err = PTR_ERR(ipage);
515 goto out;
516 }
517
518 if (f2fs_has_inline_data(inode)) {
519 if (truncate_inline_inode(ipage, from))
520 set_page_dirty(ipage);
521 f2fs_put_page(ipage, 1);
522 truncate_page = true;
523 goto out;
524 }
525
526 set_new_dnode(&dn, inode, ipage, NULL, 0);
527 err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE);
528 if (err) {
529 if (err == -ENOENT)
530 goto free_next;
531 goto out;
532 }
533
534 count = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
535
536 count -= dn.ofs_in_node;
537 f2fs_bug_on(sbi, count < 0);
538
539 if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
540 truncate_data_blocks_range(&dn, count);
541 free_from += count;
542 }
543
544 f2fs_put_dnode(&dn);
545 free_next:
546 err = truncate_inode_blocks(inode, free_from);
547 out:
548 if (lock)
549 f2fs_unlock_op(sbi);
550
551 /* lastly zero out the first data page */
552 if (!err)
553 err = truncate_partial_data_page(inode, from, truncate_page);
554
555 trace_f2fs_truncate_blocks_exit(inode, err);
556 return err;
557 }
558
559 void f2fs_truncate(struct inode *inode)
560 {
561 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
562 S_ISLNK(inode->i_mode)))
563 return;
564
565 trace_f2fs_truncate(inode);
566
567 /* we should check inline_data size */
568 if (f2fs_has_inline_data(inode) && !f2fs_may_inline_data(inode)) {
569 if (f2fs_convert_inline_inode(inode))
570 return;
571 }
572
573 if (!truncate_blocks(inode, i_size_read(inode), true)) {
574 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
575 mark_inode_dirty(inode);
576 }
577 }
578
579 int f2fs_getattr(struct vfsmount *mnt,
580 struct dentry *dentry, struct kstat *stat)
581 {
582 struct inode *inode = d_inode(dentry);
583 generic_fillattr(inode, stat);
584 stat->blocks <<= 3;
585 return 0;
586 }
587
588 #ifdef CONFIG_F2FS_FS_POSIX_ACL
589 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
590 {
591 struct f2fs_inode_info *fi = F2FS_I(inode);
592 unsigned int ia_valid = attr->ia_valid;
593
594 if (ia_valid & ATTR_UID)
595 inode->i_uid = attr->ia_uid;
596 if (ia_valid & ATTR_GID)
597 inode->i_gid = attr->ia_gid;
598 if (ia_valid & ATTR_ATIME)
599 inode->i_atime = timespec_trunc(attr->ia_atime,
600 inode->i_sb->s_time_gran);
601 if (ia_valid & ATTR_MTIME)
602 inode->i_mtime = timespec_trunc(attr->ia_mtime,
603 inode->i_sb->s_time_gran);
604 if (ia_valid & ATTR_CTIME)
605 inode->i_ctime = timespec_trunc(attr->ia_ctime,
606 inode->i_sb->s_time_gran);
607 if (ia_valid & ATTR_MODE) {
608 umode_t mode = attr->ia_mode;
609
610 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
611 mode &= ~S_ISGID;
612 set_acl_inode(fi, mode);
613 }
614 }
615 #else
616 #define __setattr_copy setattr_copy
617 #endif
618
619 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
620 {
621 struct inode *inode = d_inode(dentry);
622 struct f2fs_inode_info *fi = F2FS_I(inode);
623 int err;
624
625 err = inode_change_ok(inode, attr);
626 if (err)
627 return err;
628
629 if (attr->ia_valid & ATTR_SIZE) {
630 if (attr->ia_size != i_size_read(inode)) {
631 truncate_setsize(inode, attr->ia_size);
632 f2fs_truncate(inode);
633 f2fs_balance_fs(F2FS_I_SB(inode));
634 } else {
635 /*
636 * giving a chance to truncate blocks past EOF which
637 * are fallocated with FALLOC_FL_KEEP_SIZE.
638 */
639 f2fs_truncate(inode);
640 }
641 }
642
643 __setattr_copy(inode, attr);
644
645 if (attr->ia_valid & ATTR_MODE) {
646 err = posix_acl_chmod(inode, get_inode_mode(inode));
647 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
648 inode->i_mode = fi->i_acl_mode;
649 clear_inode_flag(fi, FI_ACL_MODE);
650 }
651 }
652
653 mark_inode_dirty(inode);
654 return err;
655 }
656
657 const struct inode_operations f2fs_file_inode_operations = {
658 .getattr = f2fs_getattr,
659 .setattr = f2fs_setattr,
660 .get_acl = f2fs_get_acl,
661 .set_acl = f2fs_set_acl,
662 #ifdef CONFIG_F2FS_FS_XATTR
663 .setxattr = generic_setxattr,
664 .getxattr = generic_getxattr,
665 .listxattr = f2fs_listxattr,
666 .removexattr = generic_removexattr,
667 #endif
668 .fiemap = f2fs_fiemap,
669 };
670
671 static void fill_zero(struct inode *inode, pgoff_t index,
672 loff_t start, loff_t len)
673 {
674 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
675 struct page *page;
676
677 if (!len)
678 return;
679
680 f2fs_balance_fs(sbi);
681
682 f2fs_lock_op(sbi);
683 page = get_new_data_page(inode, NULL, index, false);
684 f2fs_unlock_op(sbi);
685
686 if (!IS_ERR(page)) {
687 f2fs_wait_on_page_writeback(page, DATA);
688 zero_user(page, start, len);
689 set_page_dirty(page);
690 f2fs_put_page(page, 1);
691 }
692 }
693
694 int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
695 {
696 pgoff_t index;
697 int err;
698
699 for (index = pg_start; index < pg_end; index++) {
700 struct dnode_of_data dn;
701
702 set_new_dnode(&dn, inode, NULL, NULL, 0);
703 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
704 if (err) {
705 if (err == -ENOENT)
706 continue;
707 return err;
708 }
709
710 if (dn.data_blkaddr != NULL_ADDR)
711 truncate_data_blocks_range(&dn, 1);
712 f2fs_put_dnode(&dn);
713 }
714 return 0;
715 }
716
717 static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
718 {
719 pgoff_t pg_start, pg_end;
720 loff_t off_start, off_end;
721 int ret = 0;
722
723 if (!S_ISREG(inode->i_mode))
724 return -EOPNOTSUPP;
725
726 if (f2fs_has_inline_data(inode)) {
727 ret = f2fs_convert_inline_inode(inode);
728 if (ret)
729 return ret;
730 }
731
732 pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
733 pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
734
735 off_start = offset & (PAGE_CACHE_SIZE - 1);
736 off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
737
738 if (pg_start == pg_end) {
739 fill_zero(inode, pg_start, off_start,
740 off_end - off_start);
741 } else {
742 if (off_start)
743 fill_zero(inode, pg_start++, off_start,
744 PAGE_CACHE_SIZE - off_start);
745 if (off_end)
746 fill_zero(inode, pg_end, 0, off_end);
747
748 if (pg_start < pg_end) {
749 struct address_space *mapping = inode->i_mapping;
750 loff_t blk_start, blk_end;
751 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
752
753 f2fs_balance_fs(sbi);
754
755 blk_start = pg_start << PAGE_CACHE_SHIFT;
756 blk_end = pg_end << PAGE_CACHE_SHIFT;
757 truncate_inode_pages_range(mapping, blk_start,
758 blk_end - 1);
759
760 f2fs_lock_op(sbi);
761 ret = truncate_hole(inode, pg_start, pg_end);
762 f2fs_unlock_op(sbi);
763 }
764 }
765
766 return ret;
767 }
768
769 static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
770 {
771 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
772 struct dnode_of_data dn;
773 pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
774 int ret = 0;
775
776 f2fs_lock_op(sbi);
777
778 for (; end < nrpages; start++, end++) {
779 block_t new_addr, old_addr;
780
781 set_new_dnode(&dn, inode, NULL, NULL, 0);
782 ret = get_dnode_of_data(&dn, end, LOOKUP_NODE_RA);
783 if (ret && ret != -ENOENT) {
784 goto out;
785 } else if (ret == -ENOENT) {
786 new_addr = NULL_ADDR;
787 } else {
788 new_addr = dn.data_blkaddr;
789 truncate_data_blocks_range(&dn, 1);
790 f2fs_put_dnode(&dn);
791 }
792
793 if (new_addr == NULL_ADDR) {
794 set_new_dnode(&dn, inode, NULL, NULL, 0);
795 ret = get_dnode_of_data(&dn, start, LOOKUP_NODE_RA);
796 if (ret && ret != -ENOENT)
797 goto out;
798 else if (ret == -ENOENT)
799 continue;
800
801 if (dn.data_blkaddr == NULL_ADDR) {
802 f2fs_put_dnode(&dn);
803 continue;
804 } else {
805 truncate_data_blocks_range(&dn, 1);
806 }
807
808 f2fs_put_dnode(&dn);
809 } else {
810 struct page *ipage;
811
812 ipage = get_node_page(sbi, inode->i_ino);
813 if (IS_ERR(ipage)) {
814 ret = PTR_ERR(ipage);
815 goto out;
816 }
817
818 set_new_dnode(&dn, inode, ipage, NULL, 0);
819 ret = f2fs_reserve_block(&dn, start);
820 if (ret)
821 goto out;
822
823 old_addr = dn.data_blkaddr;
824 if (old_addr != NEW_ADDR && new_addr == NEW_ADDR) {
825 dn.data_blkaddr = NULL_ADDR;
826 f2fs_update_extent_cache(&dn);
827 invalidate_blocks(sbi, old_addr);
828
829 dn.data_blkaddr = new_addr;
830 set_data_blkaddr(&dn);
831 } else if (new_addr != NEW_ADDR) {
832 struct node_info ni;
833 struct f2fs_summary sum;
834
835 get_node_info(sbi, dn.nid, &ni);
836 set_summary(&sum, dn.nid, dn.ofs_in_node,
837 ni.version);
838
839 f2fs_replace_block(sbi, &sum, old_addr,
840 new_addr, true);
841
842 dn.data_blkaddr = new_addr;
843 set_data_blkaddr(&dn);
844 f2fs_update_extent_cache(&dn);
845 }
846
847 f2fs_put_dnode(&dn);
848 }
849 }
850 ret = 0;
851 out:
852 f2fs_unlock_op(sbi);
853 return ret;
854 }
855
856 static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
857 {
858 pgoff_t pg_start, pg_end;
859 loff_t new_size;
860 int ret;
861
862 if (!S_ISREG(inode->i_mode))
863 return -EINVAL;
864
865 if (offset + len >= i_size_read(inode))
866 return -EINVAL;
867
868 /* collapse range should be aligned to block size of f2fs. */
869 if (offset & (F2FS_BLKSIZE - 1) || len & (F2FS_BLKSIZE - 1))
870 return -EINVAL;
871
872 pg_start = offset >> PAGE_CACHE_SHIFT;
873 pg_end = (offset + len) >> PAGE_CACHE_SHIFT;
874
875 /* write out all dirty pages from offset */
876 ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
877 if (ret)
878 return ret;
879
880 truncate_pagecache(inode, offset);
881
882 ret = f2fs_do_collapse(inode, pg_start, pg_end);
883 if (ret)
884 return ret;
885
886 new_size = i_size_read(inode) - len;
887
888 ret = truncate_blocks(inode, new_size, true);
889 if (!ret)
890 i_size_write(inode, new_size);
891
892 return ret;
893 }
894
895 static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
896 int mode)
897 {
898 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
899 struct address_space *mapping = inode->i_mapping;
900 pgoff_t index, pg_start, pg_end;
901 loff_t new_size = i_size_read(inode);
902 loff_t off_start, off_end;
903 int ret = 0;
904
905 if (!S_ISREG(inode->i_mode))
906 return -EINVAL;
907
908 ret = inode_newsize_ok(inode, (len + offset));
909 if (ret)
910 return ret;
911
912 f2fs_balance_fs(sbi);
913
914 if (f2fs_has_inline_data(inode)) {
915 ret = f2fs_convert_inline_inode(inode);
916 if (ret)
917 return ret;
918 }
919
920 ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);
921 if (ret)
922 return ret;
923
924 truncate_pagecache_range(inode, offset, offset + len - 1);
925
926 pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
927 pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
928
929 off_start = offset & (PAGE_CACHE_SIZE - 1);
930 off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
931
932 if (pg_start == pg_end) {
933 fill_zero(inode, pg_start, off_start, off_end - off_start);
934 if (offset + len > new_size)
935 new_size = offset + len;
936 new_size = max_t(loff_t, new_size, offset + len);
937 } else {
938 if (off_start) {
939 fill_zero(inode, pg_start++, off_start,
940 PAGE_CACHE_SIZE - off_start);
941 new_size = max_t(loff_t, new_size,
942 pg_start << PAGE_CACHE_SHIFT);
943 }
944
945 for (index = pg_start; index < pg_end; index++) {
946 struct dnode_of_data dn;
947 struct page *ipage;
948
949 f2fs_lock_op(sbi);
950
951 ipage = get_node_page(sbi, inode->i_ino);
952 if (IS_ERR(ipage)) {
953 ret = PTR_ERR(ipage);
954 f2fs_unlock_op(sbi);
955 goto out;
956 }
957
958 set_new_dnode(&dn, inode, ipage, NULL, 0);
959 ret = f2fs_reserve_block(&dn, index);
960 if (ret) {
961 f2fs_unlock_op(sbi);
962 goto out;
963 }
964
965 if (dn.data_blkaddr != NEW_ADDR) {
966 invalidate_blocks(sbi, dn.data_blkaddr);
967
968 dn.data_blkaddr = NEW_ADDR;
969 set_data_blkaddr(&dn);
970
971 dn.data_blkaddr = NULL_ADDR;
972 f2fs_update_extent_cache(&dn);
973 }
974 f2fs_put_dnode(&dn);
975 f2fs_unlock_op(sbi);
976
977 new_size = max_t(loff_t, new_size,
978 (index + 1) << PAGE_CACHE_SHIFT);
979 }
980
981 if (off_end) {
982 fill_zero(inode, pg_end, 0, off_end);
983 new_size = max_t(loff_t, new_size, offset + len);
984 }
985 }
986
987 out:
988 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) {
989 i_size_write(inode, new_size);
990 mark_inode_dirty(inode);
991 update_inode_page(inode);
992 }
993
994 return ret;
995 }
996
997 static int expand_inode_data(struct inode *inode, loff_t offset,
998 loff_t len, int mode)
999 {
1000 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1001 pgoff_t index, pg_start, pg_end;
1002 loff_t new_size = i_size_read(inode);
1003 loff_t off_start, off_end;
1004 int ret = 0;
1005
1006 f2fs_balance_fs(sbi);
1007
1008 ret = inode_newsize_ok(inode, (len + offset));
1009 if (ret)
1010 return ret;
1011
1012 if (f2fs_has_inline_data(inode)) {
1013 ret = f2fs_convert_inline_inode(inode);
1014 if (ret)
1015 return ret;
1016 }
1017
1018 pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
1019 pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
1020
1021 off_start = offset & (PAGE_CACHE_SIZE - 1);
1022 off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
1023
1024 f2fs_lock_op(sbi);
1025
1026 for (index = pg_start; index <= pg_end; index++) {
1027 struct dnode_of_data dn;
1028
1029 if (index == pg_end && !off_end)
1030 goto noalloc;
1031
1032 set_new_dnode(&dn, inode, NULL, NULL, 0);
1033 ret = f2fs_reserve_block(&dn, index);
1034 if (ret)
1035 break;
1036 noalloc:
1037 if (pg_start == pg_end)
1038 new_size = offset + len;
1039 else if (index == pg_start && off_start)
1040 new_size = (index + 1) << PAGE_CACHE_SHIFT;
1041 else if (index == pg_end)
1042 new_size = (index << PAGE_CACHE_SHIFT) + off_end;
1043 else
1044 new_size += PAGE_CACHE_SIZE;
1045 }
1046
1047 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
1048 i_size_read(inode) < new_size) {
1049 i_size_write(inode, new_size);
1050 mark_inode_dirty(inode);
1051 update_inode_page(inode);
1052 }
1053 f2fs_unlock_op(sbi);
1054
1055 return ret;
1056 }
1057
1058 static long f2fs_fallocate(struct file *file, int mode,
1059 loff_t offset, loff_t len)
1060 {
1061 struct inode *inode = file_inode(file);
1062 long ret = 0;
1063
1064 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
1065 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE))
1066 return -EOPNOTSUPP;
1067
1068 mutex_lock(&inode->i_mutex);
1069
1070 if (mode & FALLOC_FL_PUNCH_HOLE) {
1071 if (offset >= inode->i_size)
1072 goto out;
1073
1074 ret = punch_hole(inode, offset, len);
1075 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
1076 ret = f2fs_collapse_range(inode, offset, len);
1077 } else if (mode & FALLOC_FL_ZERO_RANGE) {
1078 ret = f2fs_zero_range(inode, offset, len, mode);
1079 } else {
1080 ret = expand_inode_data(inode, offset, len, mode);
1081 }
1082
1083 if (!ret) {
1084 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1085 mark_inode_dirty(inode);
1086 }
1087
1088 out:
1089 mutex_unlock(&inode->i_mutex);
1090
1091 trace_f2fs_fallocate(inode, mode, offset, len, ret);
1092 return ret;
1093 }
1094
1095 static int f2fs_release_file(struct inode *inode, struct file *filp)
1096 {
1097 /* some remained atomic pages should discarded */
1098 if (f2fs_is_atomic_file(inode))
1099 commit_inmem_pages(inode, true);
1100 if (f2fs_is_volatile_file(inode)) {
1101 set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
1102 filemap_fdatawrite(inode->i_mapping);
1103 clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
1104 }
1105 return 0;
1106 }
1107
1108 #define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
1109 #define F2FS_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL)
1110
1111 static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
1112 {
1113 if (S_ISDIR(mode))
1114 return flags;
1115 else if (S_ISREG(mode))
1116 return flags & F2FS_REG_FLMASK;
1117 else
1118 return flags & F2FS_OTHER_FLMASK;
1119 }
1120
1121 static int f2fs_ioc_getflags(struct file *filp, unsigned long arg)
1122 {
1123 struct inode *inode = file_inode(filp);
1124 struct f2fs_inode_info *fi = F2FS_I(inode);
1125 unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
1126 return put_user(flags, (int __user *)arg);
1127 }
1128
1129 static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1130 {
1131 struct inode *inode = file_inode(filp);
1132 struct f2fs_inode_info *fi = F2FS_I(inode);
1133 unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE;
1134 unsigned int oldflags;
1135 int ret;
1136
1137 ret = mnt_want_write_file(filp);
1138 if (ret)
1139 return ret;
1140
1141 if (!inode_owner_or_capable(inode)) {
1142 ret = -EACCES;
1143 goto out;
1144 }
1145
1146 if (get_user(flags, (int __user *)arg)) {
1147 ret = -EFAULT;
1148 goto out;
1149 }
1150
1151 flags = f2fs_mask_flags(inode->i_mode, flags);
1152
1153 mutex_lock(&inode->i_mutex);
1154
1155 oldflags = fi->i_flags;
1156
1157 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
1158 if (!capable(CAP_LINUX_IMMUTABLE)) {
1159 mutex_unlock(&inode->i_mutex);
1160 ret = -EPERM;
1161 goto out;
1162 }
1163 }
1164
1165 flags = flags & FS_FL_USER_MODIFIABLE;
1166 flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
1167 fi->i_flags = flags;
1168 mutex_unlock(&inode->i_mutex);
1169
1170 f2fs_set_inode_flags(inode);
1171 inode->i_ctime = CURRENT_TIME;
1172 mark_inode_dirty(inode);
1173 out:
1174 mnt_drop_write_file(filp);
1175 return ret;
1176 }
1177
1178 static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
1179 {
1180 struct inode *inode = file_inode(filp);
1181
1182 return put_user(inode->i_generation, (int __user *)arg);
1183 }
1184
1185 static int f2fs_ioc_start_atomic_write(struct file *filp)
1186 {
1187 struct inode *inode = file_inode(filp);
1188
1189 if (!inode_owner_or_capable(inode))
1190 return -EACCES;
1191
1192 f2fs_balance_fs(F2FS_I_SB(inode));
1193
1194 if (f2fs_is_atomic_file(inode))
1195 return 0;
1196
1197 set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1198
1199 return f2fs_convert_inline_inode(inode);
1200 }
1201
1202 static int f2fs_ioc_commit_atomic_write(struct file *filp)
1203 {
1204 struct inode *inode = file_inode(filp);
1205 int ret;
1206
1207 if (!inode_owner_or_capable(inode))
1208 return -EACCES;
1209
1210 if (f2fs_is_volatile_file(inode))
1211 return 0;
1212
1213 ret = mnt_want_write_file(filp);
1214 if (ret)
1215 return ret;
1216
1217 if (f2fs_is_atomic_file(inode))
1218 commit_inmem_pages(inode, false);
1219
1220 ret = f2fs_sync_file(filp, 0, LONG_MAX, 0);
1221 mnt_drop_write_file(filp);
1222 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1223 return ret;
1224 }
1225
1226 static int f2fs_ioc_start_volatile_write(struct file *filp)
1227 {
1228 struct inode *inode = file_inode(filp);
1229
1230 if (!inode_owner_or_capable(inode))
1231 return -EACCES;
1232
1233 if (f2fs_is_volatile_file(inode))
1234 return 0;
1235
1236 set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
1237
1238 return f2fs_convert_inline_inode(inode);
1239 }
1240
1241 static int f2fs_ioc_release_volatile_write(struct file *filp)
1242 {
1243 struct inode *inode = file_inode(filp);
1244
1245 if (!inode_owner_or_capable(inode))
1246 return -EACCES;
1247
1248 if (!f2fs_is_volatile_file(inode))
1249 return 0;
1250
1251 if (!f2fs_is_first_block_written(inode))
1252 return truncate_partial_data_page(inode, 0, true);
1253
1254 punch_hole(inode, 0, F2FS_BLKSIZE);
1255 return 0;
1256 }
1257
1258 static int f2fs_ioc_abort_volatile_write(struct file *filp)
1259 {
1260 struct inode *inode = file_inode(filp);
1261 int ret;
1262
1263 if (!inode_owner_or_capable(inode))
1264 return -EACCES;
1265
1266 ret = mnt_want_write_file(filp);
1267 if (ret)
1268 return ret;
1269
1270 f2fs_balance_fs(F2FS_I_SB(inode));
1271
1272 if (f2fs_is_atomic_file(inode)) {
1273 commit_inmem_pages(inode, false);
1274 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
1275 }
1276
1277 if (f2fs_is_volatile_file(inode)) {
1278 clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
1279 filemap_fdatawrite(inode->i_mapping);
1280 set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
1281 }
1282 mnt_drop_write_file(filp);
1283 return ret;
1284 }
1285
1286 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
1287 {
1288 struct inode *inode = file_inode(filp);
1289 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1290 struct super_block *sb = sbi->sb;
1291 __u32 in;
1292
1293 if (!capable(CAP_SYS_ADMIN))
1294 return -EPERM;
1295
1296 if (get_user(in, (__u32 __user *)arg))
1297 return -EFAULT;
1298
1299 switch (in) {
1300 case F2FS_GOING_DOWN_FULLSYNC:
1301 sb = freeze_bdev(sb->s_bdev);
1302 if (sb && !IS_ERR(sb)) {
1303 f2fs_stop_checkpoint(sbi);
1304 thaw_bdev(sb->s_bdev, sb);
1305 }
1306 break;
1307 case F2FS_GOING_DOWN_METASYNC:
1308 /* do checkpoint only */
1309 f2fs_sync_fs(sb, 1);
1310 f2fs_stop_checkpoint(sbi);
1311 break;
1312 case F2FS_GOING_DOWN_NOSYNC:
1313 f2fs_stop_checkpoint(sbi);
1314 break;
1315 default:
1316 return -EINVAL;
1317 }
1318 return 0;
1319 }
1320
1321 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
1322 {
1323 struct inode *inode = file_inode(filp);
1324 struct super_block *sb = inode->i_sb;
1325 struct request_queue *q = bdev_get_queue(sb->s_bdev);
1326 struct fstrim_range range;
1327 int ret;
1328
1329 if (!capable(CAP_SYS_ADMIN))
1330 return -EPERM;
1331
1332 if (!blk_queue_discard(q))
1333 return -EOPNOTSUPP;
1334
1335 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1336 sizeof(range)))
1337 return -EFAULT;
1338
1339 range.minlen = max((unsigned int)range.minlen,
1340 q->limits.discard_granularity);
1341 ret = f2fs_trim_fs(F2FS_SB(sb), &range);
1342 if (ret < 0)
1343 return ret;
1344
1345 if (copy_to_user((struct fstrim_range __user *)arg, &range,
1346 sizeof(range)))
1347 return -EFAULT;
1348 return 0;
1349 }
1350
1351 static bool uuid_is_nonzero(__u8 u[16])
1352 {
1353 int i;
1354
1355 for (i = 0; i < 16; i++)
1356 if (u[i])
1357 return true;
1358 return false;
1359 }
1360
1361 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
1362 {
1363 #ifdef CONFIG_F2FS_FS_ENCRYPTION
1364 struct f2fs_encryption_policy policy;
1365 struct inode *inode = file_inode(filp);
1366
1367 if (copy_from_user(&policy, (struct f2fs_encryption_policy __user *)arg,
1368 sizeof(policy)))
1369 return -EFAULT;
1370
1371 if (f2fs_has_inline_data(inode)) {
1372 int ret = f2fs_convert_inline_inode(inode);
1373 if (ret)
1374 return ret;
1375 }
1376
1377 return f2fs_process_policy(&policy, inode);
1378 #else
1379 return -EOPNOTSUPP;
1380 #endif
1381 }
1382
1383 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
1384 {
1385 #ifdef CONFIG_F2FS_FS_ENCRYPTION
1386 struct f2fs_encryption_policy policy;
1387 struct inode *inode = file_inode(filp);
1388 int err;
1389
1390 err = f2fs_get_policy(inode, &policy);
1391 if (err)
1392 return err;
1393
1394 if (copy_to_user((struct f2fs_encryption_policy __user *)arg, &policy,
1395 sizeof(policy)))
1396 return -EFAULT;
1397 return 0;
1398 #else
1399 return -EOPNOTSUPP;
1400 #endif
1401 }
1402
1403 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
1404 {
1405 struct inode *inode = file_inode(filp);
1406 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1407 int err;
1408
1409 if (!f2fs_sb_has_crypto(inode->i_sb))
1410 return -EOPNOTSUPP;
1411
1412 if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
1413 goto got_it;
1414
1415 err = mnt_want_write_file(filp);
1416 if (err)
1417 return err;
1418
1419 /* update superblock with uuid */
1420 generate_random_uuid(sbi->raw_super->encrypt_pw_salt);
1421
1422 err = f2fs_commit_super(sbi);
1423
1424 mnt_drop_write_file(filp);
1425 if (err) {
1426 /* undo new data */
1427 memset(sbi->raw_super->encrypt_pw_salt, 0, 16);
1428 return err;
1429 }
1430 got_it:
1431 if (copy_to_user((__u8 __user *)arg, sbi->raw_super->encrypt_pw_salt,
1432 16))
1433 return -EFAULT;
1434 return 0;
1435 }
1436
1437 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1438 {
1439 switch (cmd) {
1440 case F2FS_IOC_GETFLAGS:
1441 return f2fs_ioc_getflags(filp, arg);
1442 case F2FS_IOC_SETFLAGS:
1443 return f2fs_ioc_setflags(filp, arg);
1444 case F2FS_IOC_GETVERSION:
1445 return f2fs_ioc_getversion(filp, arg);
1446 case F2FS_IOC_START_ATOMIC_WRITE:
1447 return f2fs_ioc_start_atomic_write(filp);
1448 case F2FS_IOC_COMMIT_ATOMIC_WRITE:
1449 return f2fs_ioc_commit_atomic_write(filp);
1450 case F2FS_IOC_START_VOLATILE_WRITE:
1451 return f2fs_ioc_start_volatile_write(filp);
1452 case F2FS_IOC_RELEASE_VOLATILE_WRITE:
1453 return f2fs_ioc_release_volatile_write(filp);
1454 case F2FS_IOC_ABORT_VOLATILE_WRITE:
1455 return f2fs_ioc_abort_volatile_write(filp);
1456 case F2FS_IOC_SHUTDOWN:
1457 return f2fs_ioc_shutdown(filp, arg);
1458 case FITRIM:
1459 return f2fs_ioc_fitrim(filp, arg);
1460 case F2FS_IOC_SET_ENCRYPTION_POLICY:
1461 return f2fs_ioc_set_encryption_policy(filp, arg);
1462 case F2FS_IOC_GET_ENCRYPTION_POLICY:
1463 return f2fs_ioc_get_encryption_policy(filp, arg);
1464 case F2FS_IOC_GET_ENCRYPTION_PWSALT:
1465 return f2fs_ioc_get_encryption_pwsalt(filp, arg);
1466 default:
1467 return -ENOTTY;
1468 }
1469 }
1470
1471 #ifdef CONFIG_COMPAT
1472 long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1473 {
1474 switch (cmd) {
1475 case F2FS_IOC32_GETFLAGS:
1476 cmd = F2FS_IOC_GETFLAGS;
1477 break;
1478 case F2FS_IOC32_SETFLAGS:
1479 cmd = F2FS_IOC_SETFLAGS;
1480 break;
1481 default:
1482 return -ENOIOCTLCMD;
1483 }
1484 return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1485 }
1486 #endif
1487
1488 const struct file_operations f2fs_file_operations = {
1489 .llseek = f2fs_llseek,
1490 .read_iter = generic_file_read_iter,
1491 .write_iter = generic_file_write_iter,
1492 .open = generic_file_open,
1493 .release = f2fs_release_file,
1494 .mmap = f2fs_file_mmap,
1495 .fsync = f2fs_sync_file,
1496 .fallocate = f2fs_fallocate,
1497 .unlocked_ioctl = f2fs_ioctl,
1498 #ifdef CONFIG_COMPAT
1499 .compat_ioctl = f2fs_compat_ioctl,
1500 #endif
1501 .splice_read = generic_file_splice_read,
1502 .splice_write = iter_file_splice_write,
1503 };
Linux kernel - Deliverables
This page took 0.061042 seconds and 6 git commands to generate.