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>
18 #include <linux/quotaops.h>
24 #include <trace/events/f2fs.h>
26 static struct inode
*f2fs_new_inode(struct inode
*dir
, umode_t mode
)
28 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
31 bool nid_free
= false;
35 inode
= new_inode(dir
->i_sb
);
37 return ERR_PTR(-ENOMEM
);
40 if (!f2fs_alloc_nid(sbi
, &ino
)) {
49 inode_init_owner(inode
, dir
, mode
);
53 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= current_time(inode
);
54 F2FS_I(inode
)->i_crtime
= inode
->i_mtime
;
55 inode
->i_generation
= sbi
->s_next_generation
++;
57 if (S_ISDIR(inode
->i_mode
))
58 F2FS_I(inode
)->i_current_depth
= 1;
60 err
= insert_inode_locked(inode
);
66 if (f2fs_sb_has_project_quota(sbi
->sb
) &&
67 (F2FS_I(dir
)->i_flags
& F2FS_PROJINHERIT_FL
))
68 F2FS_I(inode
)->i_projid
= F2FS_I(dir
)->i_projid
;
70 F2FS_I(inode
)->i_projid
= make_kprojid(&init_user_ns
,
73 err
= dquot_initialize(inode
);
77 err
= dquot_alloc_inode(inode
);
81 set_inode_flag(inode
, FI_NEW_INODE
);
83 /* If the directory encrypted, then we should encrypt the inode. */
84 if ((f2fs_encrypted_inode(dir
) || DUMMY_ENCRYPTION_ENABLED(sbi
)) &&
85 f2fs_may_encrypt(inode
))
86 f2fs_set_encrypted_inode(inode
);
88 if (f2fs_sb_has_extra_attr(sbi
->sb
)) {
89 set_inode_flag(inode
, FI_EXTRA_ATTR
);
90 F2FS_I(inode
)->i_extra_isize
= F2FS_TOTAL_EXTRA_ATTR_SIZE
;
93 if (test_opt(sbi
, INLINE_XATTR
))
94 set_inode_flag(inode
, FI_INLINE_XATTR
);
96 if (test_opt(sbi
, INLINE_DATA
) && f2fs_may_inline_data(inode
))
97 set_inode_flag(inode
, FI_INLINE_DATA
);
98 if (f2fs_may_inline_dentry(inode
))
99 set_inode_flag(inode
, FI_INLINE_DENTRY
);
101 if (f2fs_sb_has_flexible_inline_xattr(sbi
->sb
)) {
102 f2fs_bug_on(sbi
, !f2fs_has_extra_attr(inode
));
103 if (f2fs_has_inline_xattr(inode
))
104 xattr_size
= F2FS_OPTION(sbi
).inline_xattr_size
;
105 /* Otherwise, will be 0 */
106 } else if (f2fs_has_inline_xattr(inode
) ||
107 f2fs_has_inline_dentry(inode
)) {
108 xattr_size
= DEFAULT_INLINE_XATTR_ADDRS
;
110 F2FS_I(inode
)->i_inline_xattr_size
= xattr_size
;
112 f2fs_init_extent_tree(inode
, NULL
);
114 stat_inc_inline_xattr(inode
);
115 stat_inc_inline_inode(inode
);
116 stat_inc_inline_dir(inode
);
118 F2FS_I(inode
)->i_flags
=
119 f2fs_mask_flags(mode
, F2FS_I(dir
)->i_flags
& F2FS_FL_INHERITED
);
121 if (S_ISDIR(inode
->i_mode
))
122 F2FS_I(inode
)->i_flags
|= F2FS_INDEX_FL
;
124 if (F2FS_I(inode
)->i_flags
& F2FS_PROJINHERIT_FL
)
125 set_inode_flag(inode
, FI_PROJ_INHERIT
);
127 trace_f2fs_new_inode(inode
, 0);
131 trace_f2fs_new_inode(inode
, err
);
132 make_bad_inode(inode
);
134 set_inode_flag(inode
, FI_FREE_NID
);
138 trace_f2fs_new_inode(inode
, err
);
140 inode
->i_flags
|= S_NOQUOTA
;
142 set_inode_flag(inode
, FI_FREE_NID
);
144 unlock_new_inode(inode
);
149 static int is_extension_exist(const unsigned char *s
, const char *sub
)
151 size_t slen
= strlen(s
);
152 size_t sublen
= strlen(sub
);
156 * filename format of multimedia file should be defined as:
157 * "filename + '.' + extension + (optional: '.' + temp extension)".
159 if (slen
< sublen
+ 2)
162 for (i
= 1; i
< slen
- sublen
; i
++) {
165 if (!strncasecmp(s
+ i
+ 1, sub
, sublen
))
173 * Set multimedia files as cold files for hot/cold data separation
175 static inline void set_file_temperature(struct f2fs_sb_info
*sbi
, struct inode
*inode
,
176 const unsigned char *name
)
178 __u8 (*extlist
)[F2FS_EXTENSION_LEN
] = sbi
->raw_super
->extension_list
;
179 int i
, cold_count
, hot_count
;
181 down_read(&sbi
->sb_lock
);
183 cold_count
= le32_to_cpu(sbi
->raw_super
->extension_count
);
184 hot_count
= sbi
->raw_super
->hot_ext_count
;
186 for (i
= 0; i
< cold_count
+ hot_count
; i
++) {
187 if (!is_extension_exist(name
, extlist
[i
]))
190 file_set_cold(inode
);
196 up_read(&sbi
->sb_lock
);
199 int f2fs_update_extension_list(struct f2fs_sb_info
*sbi
, const char *name
,
202 __u8 (*extlist
)[F2FS_EXTENSION_LEN
] = sbi
->raw_super
->extension_list
;
203 int cold_count
= le32_to_cpu(sbi
->raw_super
->extension_count
);
204 int hot_count
= sbi
->raw_super
->hot_ext_count
;
205 int total_count
= cold_count
+ hot_count
;
210 if (total_count
== F2FS_MAX_EXTENSION
)
213 if (!hot
&& !cold_count
)
215 if (hot
&& !hot_count
)
227 for (i
= start
; i
< count
; i
++) {
228 if (strcmp(name
, extlist
[i
]))
234 memcpy(extlist
[i
], extlist
[i
+ 1],
235 F2FS_EXTENSION_LEN
* (total_count
- i
- 1));
236 memset(extlist
[total_count
- 1], 0, F2FS_EXTENSION_LEN
);
238 sbi
->raw_super
->hot_ext_count
= hot_count
- 1;
240 sbi
->raw_super
->extension_count
=
241 cpu_to_le32(cold_count
- 1);
249 memcpy(extlist
[count
], name
, strlen(name
));
250 sbi
->raw_super
->hot_ext_count
= hot_count
+ 1;
252 char buf
[F2FS_MAX_EXTENSION
][F2FS_EXTENSION_LEN
];
254 memcpy(buf
, &extlist
[cold_count
],
255 F2FS_EXTENSION_LEN
* hot_count
);
256 memset(extlist
[cold_count
], 0, F2FS_EXTENSION_LEN
);
257 memcpy(extlist
[cold_count
], name
, strlen(name
));
258 memcpy(&extlist
[cold_count
+ 1], buf
,
259 F2FS_EXTENSION_LEN
* hot_count
);
260 sbi
->raw_super
->extension_count
= cpu_to_le32(cold_count
+ 1);
265 static int f2fs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
268 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
273 if (unlikely(f2fs_cp_error(sbi
)))
276 err
= dquot_initialize(dir
);
280 inode
= f2fs_new_inode(dir
, mode
);
282 return PTR_ERR(inode
);
284 if (!test_opt(sbi
, DISABLE_EXT_IDENTIFY
))
285 set_file_temperature(sbi
, inode
, dentry
->d_name
.name
);
287 inode
->i_op
= &f2fs_file_inode_operations
;
288 inode
->i_fop
= &f2fs_file_operations
;
289 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
293 err
= f2fs_add_link(dentry
, inode
);
298 f2fs_alloc_nid_done(sbi
, ino
);
300 d_instantiate_new(dentry
, inode
);
303 f2fs_sync_fs(sbi
->sb
, 1);
305 f2fs_balance_fs(sbi
, true);
308 f2fs_handle_failed_inode(inode
);
312 static int f2fs_link(struct dentry
*old_dentry
, struct inode
*dir
,
313 struct dentry
*dentry
)
315 struct inode
*inode
= d_inode(old_dentry
);
316 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
319 if (unlikely(f2fs_cp_error(sbi
)))
322 err
= fscrypt_prepare_link(old_dentry
, dir
, dentry
);
326 if (is_inode_flag_set(dir
, FI_PROJ_INHERIT
) &&
327 (!projid_eq(F2FS_I(dir
)->i_projid
,
328 F2FS_I(old_dentry
->d_inode
)->i_projid
)))
331 err
= dquot_initialize(dir
);
335 f2fs_balance_fs(sbi
, true);
337 inode
->i_ctime
= current_time(inode
);
340 set_inode_flag(inode
, FI_INC_LINK
);
342 err
= f2fs_add_link(dentry
, inode
);
347 d_instantiate(dentry
, inode
);
350 f2fs_sync_fs(sbi
->sb
, 1);
353 clear_inode_flag(inode
, FI_INC_LINK
);
359 struct dentry
*f2fs_get_parent(struct dentry
*child
)
361 struct qstr dotdot
= QSTR_INIT("..", 2);
363 unsigned long ino
= f2fs_inode_by_name(d_inode(child
), &dotdot
, &page
);
366 return ERR_CAST(page
);
367 return ERR_PTR(-ENOENT
);
369 return d_obtain_alias(f2fs_iget(child
->d_sb
, ino
));
372 static int __recover_dot_dentries(struct inode
*dir
, nid_t pino
)
374 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
375 struct qstr dot
= QSTR_INIT(".", 1);
376 struct qstr dotdot
= QSTR_INIT("..", 2);
377 struct f2fs_dir_entry
*de
;
381 if (f2fs_readonly(sbi
->sb
)) {
382 f2fs_msg(sbi
->sb
, KERN_INFO
,
383 "skip recovering inline_dots inode (ino:%lu, pino:%u) "
384 "in readonly mountpoint", dir
->i_ino
, pino
);
388 err
= dquot_initialize(dir
);
392 f2fs_balance_fs(sbi
, true);
396 de
= f2fs_find_entry(dir
, &dot
, &page
);
398 f2fs_put_page(page
, 0);
399 } else if (IS_ERR(page
)) {
403 err
= f2fs_do_add_link(dir
, &dot
, NULL
, dir
->i_ino
, S_IFDIR
);
408 de
= f2fs_find_entry(dir
, &dotdot
, &page
);
410 f2fs_put_page(page
, 0);
411 else if (IS_ERR(page
))
414 err
= f2fs_do_add_link(dir
, &dotdot
, NULL
, pino
, S_IFDIR
);
417 clear_inode_flag(dir
, FI_INLINE_DOTS
);
423 static struct dentry
*f2fs_lookup(struct inode
*dir
, struct dentry
*dentry
,
426 struct inode
*inode
= NULL
;
427 struct f2fs_dir_entry
*de
;
432 unsigned int root_ino
= F2FS_ROOT_INO(F2FS_I_SB(dir
));
434 trace_f2fs_lookup_start(dir
, dentry
, flags
);
436 err
= fscrypt_prepare_lookup(dir
, dentry
, flags
);
440 if (dentry
->d_name
.len
> F2FS_NAME_LEN
) {
445 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
454 ino
= le32_to_cpu(de
->ino
);
455 f2fs_put_page(page
, 0);
457 inode
= f2fs_iget(dir
->i_sb
, ino
);
459 err
= PTR_ERR(inode
);
463 if ((dir
->i_ino
== root_ino
) && f2fs_has_inline_dots(dir
)) {
464 err
= __recover_dot_dentries(dir
, root_ino
);
469 if (f2fs_has_inline_dots(inode
)) {
470 err
= __recover_dot_dentries(inode
, dir
->i_ino
);
474 if (f2fs_encrypted_inode(dir
) &&
475 (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) &&
476 !fscrypt_has_permitted_context(dir
, inode
)) {
477 f2fs_msg(inode
->i_sb
, KERN_WARNING
,
478 "Inconsistent encryption contexts: %lu/%lu",
479 dir
->i_ino
, inode
->i_ino
);
484 new = d_splice_alias(inode
, dentry
);
487 trace_f2fs_lookup_end(dir
, dentry
, ino
, err
);
492 trace_f2fs_lookup_end(dir
, dentry
, ino
, err
);
496 static int f2fs_unlink(struct inode
*dir
, struct dentry
*dentry
)
498 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
499 struct inode
*inode
= d_inode(dentry
);
500 struct f2fs_dir_entry
*de
;
504 trace_f2fs_unlink_enter(dir
, dentry
);
506 if (unlikely(f2fs_cp_error(sbi
)))
509 err
= dquot_initialize(dir
);
512 err
= dquot_initialize(inode
);
516 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
523 f2fs_balance_fs(sbi
, true);
526 err
= f2fs_acquire_orphan_inode(sbi
);
529 f2fs_put_page(page
, 0);
532 f2fs_delete_entry(de
, page
, dir
, inode
);
536 f2fs_sync_fs(sbi
->sb
, 1);
538 trace_f2fs_unlink_exit(inode
, err
);
542 static const char *f2fs_get_link(struct dentry
*dentry
,
544 struct delayed_call
*done
)
546 const char *link
= page_get_link(dentry
, inode
, done
);
547 if (!IS_ERR(link
) && !*link
) {
548 /* this is broken symlink case */
549 do_delayed_call(done
);
550 clear_delayed_call(done
);
551 link
= ERR_PTR(-ENOENT
);
556 static int f2fs_symlink(struct inode
*dir
, struct dentry
*dentry
,
559 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
561 size_t len
= strlen(symname
);
562 struct fscrypt_str disk_link
;
565 if (unlikely(f2fs_cp_error(sbi
)))
568 err
= fscrypt_prepare_symlink(dir
, symname
, len
, dir
->i_sb
->s_blocksize
,
573 err
= dquot_initialize(dir
);
577 inode
= f2fs_new_inode(dir
, S_IFLNK
| S_IRWXUGO
);
579 return PTR_ERR(inode
);
581 if (IS_ENCRYPTED(inode
))
582 inode
->i_op
= &f2fs_encrypted_symlink_inode_operations
;
584 inode
->i_op
= &f2fs_symlink_inode_operations
;
585 inode_nohighmem(inode
);
586 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
589 err
= f2fs_add_link(dentry
, inode
);
591 goto out_f2fs_handle_failed_inode
;
593 f2fs_alloc_nid_done(sbi
, inode
->i_ino
);
595 err
= fscrypt_encrypt_symlink(inode
, symname
, len
, &disk_link
);
599 err
= page_symlink(inode
, disk_link
.name
, disk_link
.len
);
602 d_instantiate_new(dentry
, inode
);
605 * Let's flush symlink data in order to avoid broken symlink as much as
606 * possible. Nevertheless, fsyncing is the best way, but there is no
607 * way to get a file descriptor in order to flush that.
609 * Note that, it needs to do dir->fsync to make this recoverable.
610 * If the symlink path is stored into inline_data, there is no
611 * performance regression.
614 filemap_write_and_wait_range(inode
->i_mapping
, 0,
618 f2fs_sync_fs(sbi
->sb
, 1);
620 f2fs_unlink(dir
, dentry
);
623 f2fs_balance_fs(sbi
, true);
624 goto out_free_encrypted_link
;
626 out_f2fs_handle_failed_inode
:
627 f2fs_handle_failed_inode(inode
);
628 out_free_encrypted_link
:
629 if (disk_link
.name
!= (unsigned char *)symname
)
630 kfree(disk_link
.name
);
634 static int f2fs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
636 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
640 if (unlikely(f2fs_cp_error(sbi
)))
643 err
= dquot_initialize(dir
);
647 inode
= f2fs_new_inode(dir
, S_IFDIR
| mode
);
649 return PTR_ERR(inode
);
651 inode
->i_op
= &f2fs_dir_inode_operations
;
652 inode
->i_fop
= &f2fs_dir_operations
;
653 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
654 inode_nohighmem(inode
);
656 set_inode_flag(inode
, FI_INC_LINK
);
658 err
= f2fs_add_link(dentry
, inode
);
663 f2fs_alloc_nid_done(sbi
, inode
->i_ino
);
665 d_instantiate_new(dentry
, inode
);
668 f2fs_sync_fs(sbi
->sb
, 1);
670 f2fs_balance_fs(sbi
, true);
674 clear_inode_flag(inode
, FI_INC_LINK
);
675 f2fs_handle_failed_inode(inode
);
679 static int f2fs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
681 struct inode
*inode
= d_inode(dentry
);
682 if (f2fs_empty_dir(inode
))
683 return f2fs_unlink(dir
, dentry
);
687 static int f2fs_mknod(struct inode
*dir
, struct dentry
*dentry
,
688 umode_t mode
, dev_t rdev
)
690 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
694 if (unlikely(f2fs_cp_error(sbi
)))
697 err
= dquot_initialize(dir
);
701 inode
= f2fs_new_inode(dir
, mode
);
703 return PTR_ERR(inode
);
705 init_special_inode(inode
, inode
->i_mode
, rdev
);
706 inode
->i_op
= &f2fs_special_inode_operations
;
709 err
= f2fs_add_link(dentry
, inode
);
714 f2fs_alloc_nid_done(sbi
, inode
->i_ino
);
716 d_instantiate_new(dentry
, inode
);
719 f2fs_sync_fs(sbi
->sb
, 1);
721 f2fs_balance_fs(sbi
, true);
724 f2fs_handle_failed_inode(inode
);
728 static int __f2fs_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
729 umode_t mode
, struct inode
**whiteout
)
731 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
735 err
= dquot_initialize(dir
);
739 inode
= f2fs_new_inode(dir
, mode
);
741 return PTR_ERR(inode
);
744 init_special_inode(inode
, inode
->i_mode
, WHITEOUT_DEV
);
745 inode
->i_op
= &f2fs_special_inode_operations
;
747 inode
->i_op
= &f2fs_file_inode_operations
;
748 inode
->i_fop
= &f2fs_file_operations
;
749 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
753 err
= f2fs_acquire_orphan_inode(sbi
);
757 err
= f2fs_do_tmpfile(inode
, dir
);
762 * add this non-linked tmpfile to orphan list, in this way we could
763 * remove all unused data of tmpfile after abnormal power-off.
765 f2fs_add_orphan_inode(inode
);
766 f2fs_alloc_nid_done(sbi
, inode
->i_ino
);
769 f2fs_i_links_write(inode
, false);
772 d_tmpfile(dentry
, inode
);
774 /* link_count was changed by d_tmpfile as well. */
776 unlock_new_inode(inode
);
778 f2fs_balance_fs(sbi
, true);
782 f2fs_release_orphan_inode(sbi
);
784 f2fs_handle_failed_inode(inode
);
788 static int f2fs_tmpfile(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
790 struct f2fs_sb_info
*sbi
= F2FS_I_SB(dir
);
792 if (unlikely(f2fs_cp_error(sbi
)))
795 if (f2fs_encrypted_inode(dir
) || DUMMY_ENCRYPTION_ENABLED(sbi
)) {
796 int err
= fscrypt_get_encryption_info(dir
);
801 return __f2fs_tmpfile(dir
, dentry
, mode
, NULL
);
804 static int f2fs_create_whiteout(struct inode
*dir
, struct inode
**whiteout
)
806 if (unlikely(f2fs_cp_error(F2FS_I_SB(dir
))))
809 return __f2fs_tmpfile(dir
, NULL
, S_IFCHR
| WHITEOUT_MODE
, whiteout
);
812 static int f2fs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
813 struct inode
*new_dir
, struct dentry
*new_dentry
,
816 struct f2fs_sb_info
*sbi
= F2FS_I_SB(old_dir
);
817 struct inode
*old_inode
= d_inode(old_dentry
);
818 struct inode
*new_inode
= d_inode(new_dentry
);
819 struct inode
*whiteout
= NULL
;
820 struct page
*old_dir_page
;
821 struct page
*old_page
, *new_page
= NULL
;
822 struct f2fs_dir_entry
*old_dir_entry
= NULL
;
823 struct f2fs_dir_entry
*old_entry
;
824 struct f2fs_dir_entry
*new_entry
;
825 bool is_old_inline
= f2fs_has_inline_dentry(old_dir
);
828 if (unlikely(f2fs_cp_error(sbi
)))
831 if (is_inode_flag_set(new_dir
, FI_PROJ_INHERIT
) &&
832 (!projid_eq(F2FS_I(new_dir
)->i_projid
,
833 F2FS_I(old_dentry
->d_inode
)->i_projid
)))
836 err
= dquot_initialize(old_dir
);
840 err
= dquot_initialize(new_dir
);
845 err
= dquot_initialize(new_inode
);
850 old_entry
= f2fs_find_entry(old_dir
, &old_dentry
->d_name
, &old_page
);
852 if (IS_ERR(old_page
))
853 err
= PTR_ERR(old_page
);
857 if (S_ISDIR(old_inode
->i_mode
)) {
858 old_dir_entry
= f2fs_parent_dir(old_inode
, &old_dir_page
);
859 if (!old_dir_entry
) {
860 if (IS_ERR(old_dir_page
))
861 err
= PTR_ERR(old_dir_page
);
866 if (flags
& RENAME_WHITEOUT
) {
867 err
= f2fs_create_whiteout(old_dir
, &whiteout
);
875 if (old_dir_entry
&& !f2fs_empty_dir(new_inode
))
879 new_entry
= f2fs_find_entry(new_dir
, &new_dentry
->d_name
,
882 if (IS_ERR(new_page
))
883 err
= PTR_ERR(new_page
);
887 f2fs_balance_fs(sbi
, true);
891 err
= f2fs_acquire_orphan_inode(sbi
);
895 f2fs_set_link(new_dir
, new_entry
, new_page
, old_inode
);
897 new_inode
->i_ctime
= current_time(new_inode
);
898 down_write(&F2FS_I(new_inode
)->i_sem
);
900 f2fs_i_links_write(new_inode
, false);
901 f2fs_i_links_write(new_inode
, false);
902 up_write(&F2FS_I(new_inode
)->i_sem
);
904 if (!new_inode
->i_nlink
)
905 f2fs_add_orphan_inode(new_inode
);
907 f2fs_release_orphan_inode(sbi
);
909 f2fs_balance_fs(sbi
, true);
913 err
= f2fs_add_link(new_dentry
, old_inode
);
920 f2fs_i_links_write(new_dir
, true);
923 * old entry and new entry can locate in the same inline
924 * dentry in inode, when attaching new entry in inline dentry,
925 * it could force inline dentry conversion, after that,
926 * old_entry and old_page will point to wrong address, in
927 * order to avoid this, let's do the check and update here.
929 if (is_old_inline
&& !f2fs_has_inline_dentry(old_dir
)) {
930 f2fs_put_page(old_page
, 0);
933 old_entry
= f2fs_find_entry(old_dir
,
934 &old_dentry
->d_name
, &old_page
);
937 if (IS_ERR(old_page
))
938 err
= PTR_ERR(old_page
);
945 down_write(&F2FS_I(old_inode
)->i_sem
);
946 if (!old_dir_entry
|| whiteout
)
947 file_lost_pino(old_inode
);
949 F2FS_I(old_inode
)->i_pino
= new_dir
->i_ino
;
950 up_write(&F2FS_I(old_inode
)->i_sem
);
952 old_inode
->i_ctime
= current_time(old_inode
);
953 f2fs_mark_inode_dirty_sync(old_inode
, false);
955 f2fs_delete_entry(old_entry
, old_page
, old_dir
, NULL
);
958 whiteout
->i_state
|= I_LINKABLE
;
959 set_inode_flag(whiteout
, FI_INC_LINK
);
960 err
= f2fs_add_link(old_dentry
, whiteout
);
963 whiteout
->i_state
&= ~I_LINKABLE
;
968 if (old_dir
!= new_dir
&& !whiteout
)
969 f2fs_set_link(old_inode
, old_dir_entry
,
970 old_dir_page
, new_dir
);
972 f2fs_put_page(old_dir_page
, 0);
973 f2fs_i_links_write(old_dir
, false);
975 if (F2FS_OPTION(sbi
).fsync_mode
== FSYNC_MODE_STRICT
) {
976 f2fs_add_ino_entry(sbi
, new_dir
->i_ino
, TRANS_DIR_INO
);
977 if (S_ISDIR(old_inode
->i_mode
))
978 f2fs_add_ino_entry(sbi
, old_inode
->i_ino
,
984 if (IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
))
985 f2fs_sync_fs(sbi
->sb
, 1);
991 f2fs_put_page(new_page
, 0);
997 f2fs_put_page(old_dir_page
, 0);
999 f2fs_put_page(old_page
, 0);
1004 static int f2fs_cross_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1005 struct inode
*new_dir
, struct dentry
*new_dentry
)
1007 struct f2fs_sb_info
*sbi
= F2FS_I_SB(old_dir
);
1008 struct inode
*old_inode
= d_inode(old_dentry
);
1009 struct inode
*new_inode
= d_inode(new_dentry
);
1010 struct page
*old_dir_page
, *new_dir_page
;
1011 struct page
*old_page
, *new_page
;
1012 struct f2fs_dir_entry
*old_dir_entry
= NULL
, *new_dir_entry
= NULL
;
1013 struct f2fs_dir_entry
*old_entry
, *new_entry
;
1014 int old_nlink
= 0, new_nlink
= 0;
1017 if (unlikely(f2fs_cp_error(sbi
)))
1020 if ((is_inode_flag_set(new_dir
, FI_PROJ_INHERIT
) &&
1021 !projid_eq(F2FS_I(new_dir
)->i_projid
,
1022 F2FS_I(old_dentry
->d_inode
)->i_projid
)) ||
1023 (is_inode_flag_set(new_dir
, FI_PROJ_INHERIT
) &&
1024 !projid_eq(F2FS_I(old_dir
)->i_projid
,
1025 F2FS_I(new_dentry
->d_inode
)->i_projid
)))
1028 err
= dquot_initialize(old_dir
);
1032 err
= dquot_initialize(new_dir
);
1036 old_entry
= f2fs_find_entry(old_dir
, &old_dentry
->d_name
, &old_page
);
1038 if (IS_ERR(old_page
))
1039 err
= PTR_ERR(old_page
);
1043 new_entry
= f2fs_find_entry(new_dir
, &new_dentry
->d_name
, &new_page
);
1045 if (IS_ERR(new_page
))
1046 err
= PTR_ERR(new_page
);
1050 /* prepare for updating ".." directory entry info later */
1051 if (old_dir
!= new_dir
) {
1052 if (S_ISDIR(old_inode
->i_mode
)) {
1053 old_dir_entry
= f2fs_parent_dir(old_inode
,
1055 if (!old_dir_entry
) {
1056 if (IS_ERR(old_dir_page
))
1057 err
= PTR_ERR(old_dir_page
);
1062 if (S_ISDIR(new_inode
->i_mode
)) {
1063 new_dir_entry
= f2fs_parent_dir(new_inode
,
1065 if (!new_dir_entry
) {
1066 if (IS_ERR(new_dir_page
))
1067 err
= PTR_ERR(new_dir_page
);
1074 * If cross rename between file and directory those are not
1075 * in the same directory, we will inc nlink of file's parent
1076 * later, so we should check upper boundary of its nlink.
1078 if ((!old_dir_entry
|| !new_dir_entry
) &&
1079 old_dir_entry
!= new_dir_entry
) {
1080 old_nlink
= old_dir_entry
? -1 : 1;
1081 new_nlink
= -old_nlink
;
1083 if ((old_nlink
> 0 && old_dir
->i_nlink
>= F2FS_LINK_MAX
) ||
1084 (new_nlink
> 0 && new_dir
->i_nlink
>= F2FS_LINK_MAX
))
1088 f2fs_balance_fs(sbi
, true);
1092 /* update ".." directory entry info of old dentry */
1094 f2fs_set_link(old_inode
, old_dir_entry
, old_dir_page
, new_dir
);
1096 /* update ".." directory entry info of new dentry */
1098 f2fs_set_link(new_inode
, new_dir_entry
, new_dir_page
, old_dir
);
1100 /* update directory entry info of old dir inode */
1101 f2fs_set_link(old_dir
, old_entry
, old_page
, new_inode
);
1103 down_write(&F2FS_I(old_inode
)->i_sem
);
1104 file_lost_pino(old_inode
);
1105 up_write(&F2FS_I(old_inode
)->i_sem
);
1107 old_dir
->i_ctime
= current_time(old_dir
);
1109 down_write(&F2FS_I(old_dir
)->i_sem
);
1110 f2fs_i_links_write(old_dir
, old_nlink
> 0);
1111 up_write(&F2FS_I(old_dir
)->i_sem
);
1113 f2fs_mark_inode_dirty_sync(old_dir
, false);
1115 /* update directory entry info of new dir inode */
1116 f2fs_set_link(new_dir
, new_entry
, new_page
, old_inode
);
1118 down_write(&F2FS_I(new_inode
)->i_sem
);
1119 file_lost_pino(new_inode
);
1120 up_write(&F2FS_I(new_inode
)->i_sem
);
1122 new_dir
->i_ctime
= current_time(new_dir
);
1124 down_write(&F2FS_I(new_dir
)->i_sem
);
1125 f2fs_i_links_write(new_dir
, new_nlink
> 0);
1126 up_write(&F2FS_I(new_dir
)->i_sem
);
1128 f2fs_mark_inode_dirty_sync(new_dir
, false);
1130 if (F2FS_OPTION(sbi
).fsync_mode
== FSYNC_MODE_STRICT
) {
1131 f2fs_add_ino_entry(sbi
, old_dir
->i_ino
, TRANS_DIR_INO
);
1132 f2fs_add_ino_entry(sbi
, new_dir
->i_ino
, TRANS_DIR_INO
);
1135 f2fs_unlock_op(sbi
);
1137 if (IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
))
1138 f2fs_sync_fs(sbi
->sb
, 1);
1141 if (new_dir_entry
) {
1142 f2fs_put_page(new_dir_page
, 0);
1145 if (old_dir_entry
) {
1146 f2fs_put_page(old_dir_page
, 0);
1149 f2fs_put_page(new_page
, 0);
1151 f2fs_put_page(old_page
, 0);
1156 static int f2fs_rename2(struct inode
*old_dir
, struct dentry
*old_dentry
,
1157 struct inode
*new_dir
, struct dentry
*new_dentry
,
1162 if (flags
& ~(RENAME_NOREPLACE
| RENAME_EXCHANGE
| RENAME_WHITEOUT
))
1165 err
= fscrypt_prepare_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
1170 if (flags
& RENAME_EXCHANGE
) {
1171 return f2fs_cross_rename(old_dir
, old_dentry
,
1172 new_dir
, new_dentry
);
1175 * VFS has already handled the new dentry existence case,
1176 * here, we just deal with "RENAME_NOREPLACE" as regular rename.
1178 return f2fs_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
1181 static const char *f2fs_encrypted_get_link(struct dentry
*dentry
,
1182 struct inode
*inode
,
1183 struct delayed_call
*done
)
1189 return ERR_PTR(-ECHILD
);
1191 page
= read_mapping_page(inode
->i_mapping
, 0, NULL
);
1193 return ERR_CAST(page
);
1195 target
= fscrypt_get_symlink(inode
, page_address(page
),
1196 inode
->i_sb
->s_blocksize
, done
);
1201 const struct inode_operations f2fs_encrypted_symlink_inode_operations
= {
1202 .get_link
= f2fs_encrypted_get_link
,
1203 .getattr
= f2fs_getattr
,
1204 .setattr
= f2fs_setattr
,
1205 #ifdef CONFIG_F2FS_FS_XATTR
1206 .listxattr
= f2fs_listxattr
,
1210 const struct inode_operations f2fs_dir_inode_operations
= {
1211 .create
= f2fs_create
,
1212 .lookup
= f2fs_lookup
,
1214 .unlink
= f2fs_unlink
,
1215 .symlink
= f2fs_symlink
,
1216 .mkdir
= f2fs_mkdir
,
1217 .rmdir
= f2fs_rmdir
,
1218 .mknod
= f2fs_mknod
,
1219 .rename
= f2fs_rename2
,
1220 .tmpfile
= f2fs_tmpfile
,
1221 .getattr
= f2fs_getattr
,
1222 .setattr
= f2fs_setattr
,
1223 .get_acl
= f2fs_get_acl
,
1224 .set_acl
= f2fs_set_acl
,
1225 #ifdef CONFIG_F2FS_FS_XATTR
1226 .listxattr
= f2fs_listxattr
,
1230 const struct inode_operations f2fs_symlink_inode_operations
= {
1231 .get_link
= f2fs_get_link
,
1232 .getattr
= f2fs_getattr
,
1233 .setattr
= f2fs_setattr
,
1234 #ifdef CONFIG_F2FS_FS_XATTR
1235 .listxattr
= f2fs_listxattr
,
1239 const struct inode_operations f2fs_special_inode_operations
= {
1240 .getattr
= f2fs_getattr
,
1241 .setattr
= f2fs_setattr
,
1242 .get_acl
= f2fs_get_acl
,
1243 .set_acl
= f2fs_set_acl
,
1244 #ifdef CONFIG_F2FS_FS_XATTR
1245 .listxattr
= f2fs_listxattr
,