4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
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.
12 #include <linux/f2fs_fs.h>
13 #include <linux/pagemap.h>
14 #include <linux/sched.h>
15 #include <linux/ctype.h>
16 #include <linux/dcache.h>
17 #include <linux/namei.h>
23 #include <trace/events/f2fs.h>
25 static struct inode
*f2fs_new_inode(struct inode
*dir
, umode_t mode
)
27 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
30 bool nid_free
= false;
33 inode
= new_inode(dir
->i_sb
);
35 return ERR_PTR(-ENOMEM
);
38 if (!alloc_nid(sbi
, &ino
)) {
45 inode_init_owner(inode
, dir
, mode
);
49 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
50 inode
->i_generation
= sbi
->s_next_generation
++;
52 err
= insert_inode_locked(inode
);
59 /* If the directory encrypted, then we should encrypt the inode. */
60 if (f2fs_encrypted_inode(dir
) && f2fs_may_encrypt(inode
))
61 f2fs_set_encrypted_inode(inode
);
63 if (test_opt(sbi
, INLINE_DATA
) && f2fs_may_inline_data(inode
))
64 set_inode_flag(F2FS_I(inode
), FI_INLINE_DATA
);
65 if (f2fs_may_inline_dentry(inode
))
66 set_inode_flag(F2FS_I(inode
), FI_INLINE_DENTRY
);
68 f2fs_init_extent_tree(inode
, NULL
);
70 stat_inc_inline_xattr(inode
);
71 stat_inc_inline_inode(inode
);
72 stat_inc_inline_dir(inode
);
74 trace_f2fs_new_inode(inode
, 0);
75 mark_inode_dirty(inode
);
79 trace_f2fs_new_inode(inode
, err
);
80 make_bad_inode(inode
);
82 set_inode_flag(F2FS_I(inode
), FI_FREE_NID
);
87 static int is_multimedia_file(const unsigned char *s
, const char *sub
)
89 size_t slen
= strlen(s
);
90 size_t sublen
= strlen(sub
);
93 * filename format of multimedia file should be defined as:
94 * "filename + '.' + extension".
96 if (slen
< sublen
+ 2)
99 if (s
[slen
- sublen
- 1] != '.')
102 return !strncasecmp(s
+ slen
- sublen
, sub
, sublen
);
106 * Set multimedia files as cold files for hot/cold data separation
108 static inline void set_cold_files(struct f2fs_sb_info
*sbi
, struct inode
*inode
,
109 const unsigned char *name
)
112 __u8 (*extlist
)[8] = sbi
->raw_super
->extension_list
;
114 int count
= le32_to_cpu(sbi
->raw_super
->extension_count
);
115 for (i
= 0; i
< count
; i
++) {
116 if (is_multimedia_file(name
, extlist
[i
])) {
117 file_set_cold(inode
);
123 static int f2fs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
126 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
131 inode
= f2fs_new_inode(dir
, mode
);
133 return PTR_ERR(inode
);
135 if (!test_opt(sbi
, DISABLE_EXT_IDENTIFY
))
136 set_cold_files(sbi
, inode
, dentry
->d_name
.name
);
138 inode
->i_op
= &f2fs_file_inode_operations
;
139 inode
->i_fop
= &f2fs_file_operations
;
140 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
143 f2fs_balance_fs(sbi
, true);
146 err
= f2fs_add_link(dentry
, inode
);
151 alloc_nid_done(sbi
, ino
);
153 d_instantiate(dentry
, inode
);
154 unlock_new_inode(inode
);
157 f2fs_sync_fs(sbi
->sb
, 1);
160 handle_failed_inode(inode
);
164 static int f2fs_link(struct dentry
*old_dentry
, struct inode
*dir
,
165 struct dentry
*dentry
)
167 struct inode
*inode
= d_inode(old_dentry
);
168 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
171 if (f2fs_encrypted_inode(dir
) &&
172 !f2fs_is_child_context_consistent_with_parent(dir
, inode
))
175 f2fs_balance_fs(sbi
, true);
177 inode
->i_ctime
= CURRENT_TIME
;
180 set_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
182 err
= f2fs_add_link(dentry
, inode
);
187 d_instantiate(dentry
, inode
);
190 f2fs_sync_fs(sbi
->sb
, 1);
193 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
199 struct dentry
*f2fs_get_parent(struct dentry
*child
)
201 struct qstr dotdot
= QSTR_INIT("..", 2);
202 unsigned long ino
= f2fs_inode_by_name(d_inode(child
), &dotdot
);
204 return ERR_PTR(-ENOENT
);
205 return d_obtain_alias(f2fs_iget(d_inode(child
)->i_sb
, ino
));
208 static int __recover_dot_dentries(struct inode
*dir
, nid_t pino
)
210 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
211 struct qstr dot
= QSTR_INIT(".", 1);
212 struct qstr dotdot
= QSTR_INIT("..", 2);
213 struct f2fs_dir_entry
*de
;
217 if (f2fs_readonly(sbi
->sb
)) {
218 f2fs_msg(sbi
->sb
, KERN_INFO
,
219 "skip recovering inline_dots inode (ino:%lu, pino:%u) "
220 "in readonly mountpoint", dir
->i_ino
, pino
);
224 f2fs_balance_fs(sbi
, true);
228 de
= f2fs_find_entry(dir
, &dot
, &page
);
230 f2fs_dentry_kunmap(dir
, page
);
231 f2fs_put_page(page
, 0);
233 err
= __f2fs_add_link(dir
, &dot
, NULL
, dir
->i_ino
, S_IFDIR
);
238 de
= f2fs_find_entry(dir
, &dotdot
, &page
);
240 f2fs_dentry_kunmap(dir
, page
);
241 f2fs_put_page(page
, 0);
243 err
= __f2fs_add_link(dir
, &dotdot
, NULL
, pino
, S_IFDIR
);
247 clear_inode_flag(F2FS_I(dir
), FI_INLINE_DOTS
);
248 mark_inode_dirty(dir
);
255 static struct dentry
*f2fs_lookup(struct inode
*dir
, struct dentry
*dentry
,
258 struct inode
*inode
= NULL
;
259 struct f2fs_dir_entry
*de
;
264 if (dentry
->d_name
.len
> F2FS_NAME_LEN
)
265 return ERR_PTR(-ENAMETOOLONG
);
267 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
269 return d_splice_alias(inode
, dentry
);
271 ino
= le32_to_cpu(de
->ino
);
272 f2fs_dentry_kunmap(dir
, page
);
273 f2fs_put_page(page
, 0);
275 inode
= f2fs_iget(dir
->i_sb
, ino
);
277 return ERR_CAST(inode
);
279 if (f2fs_has_inline_dots(inode
)) {
280 err
= __recover_dot_dentries(inode
, dir
->i_ino
);
284 return d_splice_alias(inode
, dentry
);
291 static int f2fs_unlink(struct inode
*dir
, struct dentry
*dentry
)
293 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
294 struct inode
*inode
= d_inode(dentry
);
295 struct f2fs_dir_entry
*de
;
299 trace_f2fs_unlink_enter(dir
, dentry
);
301 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
305 f2fs_balance_fs(sbi
, true);
308 err
= acquire_orphan_inode(sbi
);
311 f2fs_dentry_kunmap(dir
, page
);
312 f2fs_put_page(page
, 0);
315 f2fs_delete_entry(de
, page
, dir
, inode
);
318 /* In order to evict this inode, we set it dirty */
319 mark_inode_dirty(inode
);
322 f2fs_sync_fs(sbi
->sb
, 1);
324 trace_f2fs_unlink_exit(inode
, err
);
328 static const char *f2fs_get_link(struct dentry
*dentry
,
330 struct delayed_call
*done
)
332 const char *link
= page_get_link(dentry
, inode
, done
);
333 if (!IS_ERR(link
) && !*link
) {
334 /* this is broken symlink case */
335 do_delayed_call(done
);
336 clear_delayed_call(done
);
337 link
= ERR_PTR(-ENOENT
);
342 static int f2fs_symlink(struct inode
*dir
, struct dentry
*dentry
,
345 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
347 size_t len
= strlen(symname
);
350 struct f2fs_str disk_link
= FSTR_INIT(NULL
, 0);
351 struct f2fs_encrypted_symlink_data
*sd
= NULL
;
354 if (len
> dir
->i_sb
->s_blocksize
)
355 return -ENAMETOOLONG
;
357 inode
= f2fs_new_inode(dir
, S_IFLNK
| S_IRWXUGO
);
359 return PTR_ERR(inode
);
361 if (f2fs_encrypted_inode(inode
))
362 inode
->i_op
= &f2fs_encrypted_symlink_inode_operations
;
364 inode
->i_op
= &f2fs_symlink_inode_operations
;
365 inode_nohighmem(inode
);
366 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
368 f2fs_balance_fs(sbi
, true);
371 err
= f2fs_add_link(dentry
, inode
);
375 alloc_nid_done(sbi
, inode
->i_ino
);
377 if (f2fs_encrypted_inode(dir
)) {
378 struct qstr istr
= QSTR_INIT(symname
, len
);
380 err
= f2fs_get_encryption_info(inode
);
384 err
= f2fs_fname_crypto_alloc_buffer(inode
, len
, &disk_link
);
388 err
= f2fs_fname_usr_to_disk(inode
, &istr
, &disk_link
);
392 p_len
= encrypted_symlink_data_len(disk_link
.len
) + 1;
394 if (p_len
> dir
->i_sb
->s_blocksize
) {
399 sd
= kzalloc(p_len
, GFP_NOFS
);
404 memcpy(sd
->encrypted_path
, disk_link
.name
, disk_link
.len
);
405 sd
->len
= cpu_to_le16(disk_link
.len
);
409 p_str
= (char *)symname
;
412 err
= page_symlink(inode
, p_str
, p_len
);
415 d_instantiate(dentry
, inode
);
416 unlock_new_inode(inode
);
419 * Let's flush symlink data in order to avoid broken symlink as much as
420 * possible. Nevertheless, fsyncing is the best way, but there is no
421 * way to get a file descriptor in order to flush that.
423 * Note that, it needs to do dir->fsync to make this recoverable.
424 * If the symlink path is stored into inline_data, there is no
425 * performance regression.
428 filemap_write_and_wait_range(inode
->i_mapping
, 0, p_len
- 1);
431 f2fs_sync_fs(sbi
->sb
, 1);
433 f2fs_unlink(dir
, dentry
);
437 f2fs_fname_crypto_free_buffer(&disk_link
);
440 handle_failed_inode(inode
);
444 static int f2fs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
446 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
450 inode
= f2fs_new_inode(dir
, S_IFDIR
| mode
);
452 return PTR_ERR(inode
);
454 inode
->i_op
= &f2fs_dir_inode_operations
;
455 inode
->i_fop
= &f2fs_dir_operations
;
456 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
457 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_HIGH_ZERO
);
459 f2fs_balance_fs(sbi
, true);
461 set_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
463 err
= f2fs_add_link(dentry
, inode
);
468 alloc_nid_done(sbi
, inode
->i_ino
);
470 d_instantiate(dentry
, inode
);
471 unlock_new_inode(inode
);
474 f2fs_sync_fs(sbi
->sb
, 1);
478 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
479 handle_failed_inode(inode
);
483 static int f2fs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
485 struct inode
*inode
= d_inode(dentry
);
486 if (f2fs_empty_dir(inode
))
487 return f2fs_unlink(dir
, dentry
);
491 static int f2fs_mknod(struct inode
*dir
, struct dentry
*dentry
,
492 umode_t mode
, dev_t rdev
)
494 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
498 inode
= f2fs_new_inode(dir
, mode
);
500 return PTR_ERR(inode
);
502 init_special_inode(inode
, inode
->i_mode
, rdev
);
503 inode
->i_op
= &f2fs_special_inode_operations
;
505 f2fs_balance_fs(sbi
, true);
508 err
= f2fs_add_link(dentry
, inode
);
513 alloc_nid_done(sbi
, inode
->i_ino
);
515 d_instantiate(dentry
, inode
);
516 unlock_new_inode(inode
);
519 f2fs_sync_fs(sbi
->sb
, 1);
522 handle_failed_inode(inode
);
526 static int __f2fs_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
527 umode_t mode
, struct inode
**whiteout
)
529 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
533 inode
= f2fs_new_inode(dir
, mode
);
535 return PTR_ERR(inode
);
538 init_special_inode(inode
, inode
->i_mode
, WHITEOUT_DEV
);
539 inode
->i_op
= &f2fs_special_inode_operations
;
541 inode
->i_op
= &f2fs_file_inode_operations
;
542 inode
->i_fop
= &f2fs_file_operations
;
543 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
546 f2fs_balance_fs(sbi
, true);
549 err
= acquire_orphan_inode(sbi
);
553 err
= f2fs_do_tmpfile(inode
, dir
);
558 * add this non-linked tmpfile to orphan list, in this way we could
559 * remove all unused data of tmpfile after abnormal power-off.
561 add_orphan_inode(sbi
, inode
->i_ino
);
564 alloc_nid_done(sbi
, inode
->i_ino
);
567 inode_dec_link_count(inode
);
570 d_tmpfile(dentry
, inode
);
572 unlock_new_inode(inode
);
576 release_orphan_inode(sbi
);
578 handle_failed_inode(inode
);
582 static int f2fs_tmpfile(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
584 if (f2fs_encrypted_inode(dir
)) {
585 int err
= f2fs_get_encryption_info(dir
);
590 return __f2fs_tmpfile(dir
, dentry
, mode
, NULL
);
593 static int f2fs_create_whiteout(struct inode
*dir
, struct inode
**whiteout
)
595 return __f2fs_tmpfile(dir
, NULL
, S_IFCHR
| WHITEOUT_MODE
, whiteout
);
598 static int f2fs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
599 struct inode
*new_dir
, struct dentry
*new_dentry
,
602 struct f2fs_sb_info
*sbi
= F2FS_I_SB(old_dir
);
603 struct inode
*old_inode
= d_inode(old_dentry
);
604 struct inode
*new_inode
= d_inode(new_dentry
);
605 struct inode
*whiteout
= NULL
;
606 struct page
*old_dir_page
;
607 struct page
*old_page
, *new_page
= NULL
;
608 struct f2fs_dir_entry
*old_dir_entry
= NULL
;
609 struct f2fs_dir_entry
*old_entry
;
610 struct f2fs_dir_entry
*new_entry
;
613 if ((old_dir
!= new_dir
) && f2fs_encrypted_inode(new_dir
) &&
614 !f2fs_is_child_context_consistent_with_parent(new_dir
,
620 old_entry
= f2fs_find_entry(old_dir
, &old_dentry
->d_name
, &old_page
);
624 if (S_ISDIR(old_inode
->i_mode
)) {
626 old_dir_entry
= f2fs_parent_dir(old_inode
, &old_dir_page
);
631 if (flags
& RENAME_WHITEOUT
) {
632 err
= f2fs_create_whiteout(old_dir
, &whiteout
);
640 if (old_dir_entry
&& !f2fs_empty_dir(new_inode
))
644 new_entry
= f2fs_find_entry(new_dir
, &new_dentry
->d_name
,
649 f2fs_balance_fs(sbi
, true);
653 err
= acquire_orphan_inode(sbi
);
657 if (update_dent_inode(old_inode
, new_inode
,
658 &new_dentry
->d_name
)) {
659 release_orphan_inode(sbi
);
663 f2fs_set_link(new_dir
, new_entry
, new_page
, old_inode
);
665 new_inode
->i_ctime
= CURRENT_TIME
;
666 down_write(&F2FS_I(new_inode
)->i_sem
);
668 drop_nlink(new_inode
);
669 drop_nlink(new_inode
);
670 up_write(&F2FS_I(new_inode
)->i_sem
);
672 mark_inode_dirty(new_inode
);
674 if (!new_inode
->i_nlink
)
675 add_orphan_inode(sbi
, new_inode
->i_ino
);
677 release_orphan_inode(sbi
);
679 update_inode_page(old_inode
);
680 update_inode_page(new_inode
);
682 f2fs_balance_fs(sbi
, true);
686 err
= f2fs_add_link(new_dentry
, old_inode
);
694 update_inode_page(new_dir
);
698 down_write(&F2FS_I(old_inode
)->i_sem
);
699 file_lost_pino(old_inode
);
700 if (new_inode
&& file_enc_name(new_inode
))
701 file_set_enc_name(old_inode
);
702 up_write(&F2FS_I(old_inode
)->i_sem
);
704 old_inode
->i_ctime
= CURRENT_TIME
;
705 mark_inode_dirty(old_inode
);
707 f2fs_delete_entry(old_entry
, old_page
, old_dir
, NULL
);
710 whiteout
->i_state
|= I_LINKABLE
;
711 set_inode_flag(F2FS_I(whiteout
), FI_INC_LINK
);
712 err
= f2fs_add_link(old_dentry
, whiteout
);
715 whiteout
->i_state
&= ~I_LINKABLE
;
720 if (old_dir
!= new_dir
&& !whiteout
) {
721 f2fs_set_link(old_inode
, old_dir_entry
,
722 old_dir_page
, new_dir
);
723 update_inode_page(old_inode
);
725 f2fs_dentry_kunmap(old_inode
, old_dir_page
);
726 f2fs_put_page(old_dir_page
, 0);
729 mark_inode_dirty(old_dir
);
730 update_inode_page(old_dir
);
735 if (IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
))
736 f2fs_sync_fs(sbi
->sb
, 1);
742 f2fs_dentry_kunmap(new_dir
, new_page
);
743 f2fs_put_page(new_page
, 0);
750 f2fs_dentry_kunmap(old_inode
, old_dir_page
);
751 f2fs_put_page(old_dir_page
, 0);
754 f2fs_dentry_kunmap(old_dir
, old_page
);
755 f2fs_put_page(old_page
, 0);
760 static int f2fs_cross_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
761 struct inode
*new_dir
, struct dentry
*new_dentry
)
763 struct f2fs_sb_info
*sbi
= F2FS_I_SB(old_dir
);
764 struct inode
*old_inode
= d_inode(old_dentry
);
765 struct inode
*new_inode
= d_inode(new_dentry
);
766 struct page
*old_dir_page
, *new_dir_page
;
767 struct page
*old_page
, *new_page
;
768 struct f2fs_dir_entry
*old_dir_entry
= NULL
, *new_dir_entry
= NULL
;
769 struct f2fs_dir_entry
*old_entry
, *new_entry
;
770 int old_nlink
= 0, new_nlink
= 0;
773 if ((f2fs_encrypted_inode(old_dir
) || f2fs_encrypted_inode(new_dir
)) &&
774 (old_dir
!= new_dir
) &&
775 (!f2fs_is_child_context_consistent_with_parent(new_dir
,
777 !f2fs_is_child_context_consistent_with_parent(old_dir
,
781 old_entry
= f2fs_find_entry(old_dir
, &old_dentry
->d_name
, &old_page
);
785 new_entry
= f2fs_find_entry(new_dir
, &new_dentry
->d_name
, &new_page
);
789 /* prepare for updating ".." directory entry info later */
790 if (old_dir
!= new_dir
) {
791 if (S_ISDIR(old_inode
->i_mode
)) {
793 old_dir_entry
= f2fs_parent_dir(old_inode
,
799 if (S_ISDIR(new_inode
->i_mode
)) {
801 new_dir_entry
= f2fs_parent_dir(new_inode
,
809 * If cross rename between file and directory those are not
810 * in the same directory, we will inc nlink of file's parent
811 * later, so we should check upper boundary of its nlink.
813 if ((!old_dir_entry
|| !new_dir_entry
) &&
814 old_dir_entry
!= new_dir_entry
) {
815 old_nlink
= old_dir_entry
? -1 : 1;
816 new_nlink
= -old_nlink
;
818 if ((old_nlink
> 0 && old_inode
->i_nlink
>= F2FS_LINK_MAX
) ||
819 (new_nlink
> 0 && new_inode
->i_nlink
>= F2FS_LINK_MAX
))
823 f2fs_balance_fs(sbi
, true);
827 err
= update_dent_inode(old_inode
, new_inode
, &new_dentry
->d_name
);
830 if (file_enc_name(new_inode
))
831 file_set_enc_name(old_inode
);
833 err
= update_dent_inode(new_inode
, old_inode
, &old_dentry
->d_name
);
836 if (file_enc_name(old_inode
))
837 file_set_enc_name(new_inode
);
839 /* update ".." directory entry info of old dentry */
841 f2fs_set_link(old_inode
, old_dir_entry
, old_dir_page
, new_dir
);
843 /* update ".." directory entry info of new dentry */
845 f2fs_set_link(new_inode
, new_dir_entry
, new_dir_page
, old_dir
);
847 /* update directory entry info of old dir inode */
848 f2fs_set_link(old_dir
, old_entry
, old_page
, new_inode
);
850 down_write(&F2FS_I(old_inode
)->i_sem
);
851 file_lost_pino(old_inode
);
852 up_write(&F2FS_I(old_inode
)->i_sem
);
854 update_inode_page(old_inode
);
856 old_dir
->i_ctime
= CURRENT_TIME
;
858 down_write(&F2FS_I(old_dir
)->i_sem
);
863 up_write(&F2FS_I(old_dir
)->i_sem
);
865 mark_inode_dirty(old_dir
);
866 update_inode_page(old_dir
);
868 /* update directory entry info of new dir inode */
869 f2fs_set_link(new_dir
, new_entry
, new_page
, old_inode
);
871 down_write(&F2FS_I(new_inode
)->i_sem
);
872 file_lost_pino(new_inode
);
873 up_write(&F2FS_I(new_inode
)->i_sem
);
875 update_inode_page(new_inode
);
877 new_dir
->i_ctime
= CURRENT_TIME
;
879 down_write(&F2FS_I(new_dir
)->i_sem
);
884 up_write(&F2FS_I(new_dir
)->i_sem
);
886 mark_inode_dirty(new_dir
);
887 update_inode_page(new_dir
);
891 if (IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
))
892 f2fs_sync_fs(sbi
->sb
, 1);
896 * Still we may fail to recover name info of f2fs_inode here
897 * Drop it, once its name is set as encrypted
899 update_dent_inode(old_inode
, old_inode
, &old_dentry
->d_name
);
904 f2fs_dentry_kunmap(new_inode
, new_dir_page
);
905 f2fs_put_page(new_dir_page
, 0);
909 f2fs_dentry_kunmap(old_inode
, old_dir_page
);
910 f2fs_put_page(old_dir_page
, 0);
913 f2fs_dentry_kunmap(new_dir
, new_page
);
914 f2fs_put_page(new_page
, 0);
916 f2fs_dentry_kunmap(old_dir
, old_page
);
917 f2fs_put_page(old_page
, 0);
922 static int f2fs_rename2(struct inode
*old_dir
, struct dentry
*old_dentry
,
923 struct inode
*new_dir
, struct dentry
*new_dentry
,
926 if (flags
& ~(RENAME_NOREPLACE
| RENAME_EXCHANGE
| RENAME_WHITEOUT
))
929 if (flags
& RENAME_EXCHANGE
) {
930 return f2fs_cross_rename(old_dir
, old_dentry
,
931 new_dir
, new_dentry
);
934 * VFS has already handled the new dentry existence case,
935 * here, we just deal with "RENAME_NOREPLACE" as regular rename.
937 return f2fs_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
940 #ifdef CONFIG_F2FS_FS_ENCRYPTION
941 static const char *f2fs_encrypted_get_link(struct dentry
*dentry
,
943 struct delayed_call
*done
)
945 struct page
*cpage
= NULL
;
946 char *caddr
, *paddr
= NULL
;
947 struct f2fs_str cstr
= FSTR_INIT(NULL
, 0);
948 struct f2fs_str pstr
= FSTR_INIT(NULL
, 0);
949 struct f2fs_encrypted_symlink_data
*sd
;
950 loff_t size
= min_t(loff_t
, i_size_read(inode
), PAGE_SIZE
- 1);
951 u32 max_size
= inode
->i_sb
->s_blocksize
;
955 return ERR_PTR(-ECHILD
);
957 res
= f2fs_get_encryption_info(inode
);
961 cpage
= read_mapping_page(inode
->i_mapping
, 0, NULL
);
963 return ERR_CAST(cpage
);
964 caddr
= page_address(cpage
);
967 /* Symlink is encrypted */
968 sd
= (struct f2fs_encrypted_symlink_data
*)caddr
;
969 cstr
.len
= le16_to_cpu(sd
->len
);
971 /* this is broken symlink case */
972 if (unlikely(cstr
.len
== 0)) {
976 cstr
.name
= kmalloc(cstr
.len
, GFP_NOFS
);
981 memcpy(cstr
.name
, sd
->encrypted_path
, cstr
.len
);
983 /* this is broken symlink case */
984 if (unlikely(cstr
.name
[0] == 0)) {
989 if ((cstr
.len
+ sizeof(struct f2fs_encrypted_symlink_data
) - 1) >
991 /* Symlink data on the disk is corrupted */
995 res
= f2fs_fname_crypto_alloc_buffer(inode
, cstr
.len
, &pstr
);
999 res
= f2fs_fname_disk_to_usr(inode
, NULL
, &cstr
, &pstr
);
1007 /* Null-terminate the name */
1010 page_cache_release(cpage
);
1011 set_delayed_call(done
, kfree_link
, paddr
);
1015 f2fs_fname_crypto_free_buffer(&pstr
);
1016 page_cache_release(cpage
);
1017 return ERR_PTR(res
);
1020 const struct inode_operations f2fs_encrypted_symlink_inode_operations
= {
1021 .readlink
= generic_readlink
,
1022 .get_link
= f2fs_encrypted_get_link
,
1023 .getattr
= f2fs_getattr
,
1024 .setattr
= f2fs_setattr
,
1025 #ifdef CONFIG_F2FS_FS_XATTR
1026 .setxattr
= generic_setxattr
,
1027 .getxattr
= generic_getxattr
,
1028 .listxattr
= f2fs_listxattr
,
1029 .removexattr
= generic_removexattr
,
1034 const struct inode_operations f2fs_dir_inode_operations
= {
1035 .create
= f2fs_create
,
1036 .lookup
= f2fs_lookup
,
1038 .unlink
= f2fs_unlink
,
1039 .symlink
= f2fs_symlink
,
1040 .mkdir
= f2fs_mkdir
,
1041 .rmdir
= f2fs_rmdir
,
1042 .mknod
= f2fs_mknod
,
1043 .rename2
= f2fs_rename2
,
1044 .tmpfile
= f2fs_tmpfile
,
1045 .getattr
= f2fs_getattr
,
1046 .setattr
= f2fs_setattr
,
1047 .get_acl
= f2fs_get_acl
,
1048 .set_acl
= f2fs_set_acl
,
1049 #ifdef CONFIG_F2FS_FS_XATTR
1050 .setxattr
= generic_setxattr
,
1051 .getxattr
= generic_getxattr
,
1052 .listxattr
= f2fs_listxattr
,
1053 .removexattr
= generic_removexattr
,
1057 const struct inode_operations f2fs_symlink_inode_operations
= {
1058 .readlink
= generic_readlink
,
1059 .get_link
= f2fs_get_link
,
1060 .getattr
= f2fs_getattr
,
1061 .setattr
= f2fs_setattr
,
1062 #ifdef CONFIG_F2FS_FS_XATTR
1063 .setxattr
= generic_setxattr
,
1064 .getxattr
= generic_getxattr
,
1065 .listxattr
= f2fs_listxattr
,
1066 .removexattr
= generic_removexattr
,
1070 const struct inode_operations f2fs_special_inode_operations
= {
1071 .getattr
= f2fs_getattr
,
1072 .setattr
= f2fs_setattr
,
1073 .get_acl
= f2fs_get_acl
,
1074 .set_acl
= f2fs_set_acl
,
1075 #ifdef CONFIG_F2FS_FS_XATTR
1076 .setxattr
= generic_setxattr
,
1077 .getxattr
= generic_getxattr
,
1078 .listxattr
= f2fs_listxattr
,
1079 .removexattr
= generic_removexattr
,