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>
21 #include <trace/events/f2fs.h>
23 static struct inode
*f2fs_new_inode(struct inode
*dir
, umode_t mode
)
25 struct super_block
*sb
= dir
->i_sb
;
26 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
29 bool nid_free
= false;
32 inode
= new_inode(sb
);
34 return ERR_PTR(-ENOMEM
);
36 ilock
= mutex_lock_op(sbi
);
37 if (!alloc_nid(sbi
, &ino
)) {
38 mutex_unlock_op(sbi
, ilock
);
42 mutex_unlock_op(sbi
, ilock
);
44 inode
->i_uid
= current_fsuid();
46 if (dir
->i_mode
& S_ISGID
) {
47 inode
->i_gid
= dir
->i_gid
;
51 inode
->i_gid
= current_fsgid();
57 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
58 inode
->i_generation
= sbi
->s_next_generation
++;
60 err
= insert_inode_locked(inode
);
66 trace_f2fs_new_inode(inode
, 0);
67 mark_inode_dirty(inode
);
72 unlock_new_inode(inode
);
74 trace_f2fs_new_inode(inode
, err
);
77 alloc_nid_failed(sbi
, ino
);
81 static int is_multimedia_file(const unsigned char *s
, const char *sub
)
83 size_t slen
= strlen(s
);
84 size_t sublen
= strlen(sub
);
90 ret
= memcmp(s
+ slen
- sublen
, sub
, sublen
);
91 if (ret
) { /* compare upper case */
94 for (i
= 0; i
< sublen
&& i
< sizeof(upper_sub
); i
++)
95 upper_sub
[i
] = toupper(sub
[i
]);
96 return !memcmp(s
+ slen
- sublen
, upper_sub
, sublen
);
103 * Set multimedia files as cold files for hot/cold data separation
105 static inline void set_cold_files(struct f2fs_sb_info
*sbi
, struct inode
*inode
,
106 const unsigned char *name
)
109 __u8 (*extlist
)[8] = sbi
->raw_super
->extension_list
;
111 int count
= le32_to_cpu(sbi
->raw_super
->extension_count
);
112 for (i
= 0; i
< count
; i
++) {
113 if (is_multimedia_file(name
, extlist
[i
])) {
114 set_cold_file(inode
);
120 static int f2fs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
123 struct super_block
*sb
= dir
->i_sb
;
124 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
129 f2fs_balance_fs(sbi
);
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 ilock
= mutex_lock_op(sbi
);
144 err
= f2fs_add_link(dentry
, inode
);
145 mutex_unlock_op(sbi
, ilock
);
149 alloc_nid_done(sbi
, ino
);
152 d_instantiate(dentry
, inode
);
153 unlock_new_inode(inode
);
157 unlock_new_inode(inode
);
159 alloc_nid_failed(sbi
, ino
);
163 static int f2fs_link(struct dentry
*old_dentry
, struct inode
*dir
,
164 struct dentry
*dentry
)
166 struct inode
*inode
= old_dentry
->d_inode
;
167 struct super_block
*sb
= dir
->i_sb
;
168 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
171 f2fs_balance_fs(sbi
);
173 inode
->i_ctime
= CURRENT_TIME
;
174 atomic_inc(&inode
->i_count
);
176 set_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
177 ilock
= mutex_lock_op(sbi
);
178 err
= f2fs_add_link(dentry
, inode
);
179 mutex_unlock_op(sbi
, ilock
);
184 * This file should be checkpointed during fsync.
185 * We lost i_pino from now on.
189 d_instantiate(dentry
, inode
);
192 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
197 struct dentry
*f2fs_get_parent(struct dentry
*child
)
199 struct qstr dotdot
= QSTR_INIT("..", 2);
200 unsigned long ino
= f2fs_inode_by_name(child
->d_inode
, &dotdot
);
202 return ERR_PTR(-ENOENT
);
203 return d_obtain_alias(f2fs_iget(child
->d_inode
->i_sb
, ino
));
206 static struct dentry
*f2fs_lookup(struct inode
*dir
, struct dentry
*dentry
,
209 struct inode
*inode
= NULL
;
210 struct f2fs_dir_entry
*de
;
213 if (dentry
->d_name
.len
> F2FS_NAME_LEN
)
214 return ERR_PTR(-ENAMETOOLONG
);
216 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
218 nid_t ino
= le32_to_cpu(de
->ino
);
220 f2fs_put_page(page
, 0);
222 inode
= f2fs_iget(dir
->i_sb
, ino
);
224 return ERR_CAST(inode
);
227 return d_splice_alias(inode
, dentry
);
230 static int f2fs_unlink(struct inode
*dir
, struct dentry
*dentry
)
232 struct super_block
*sb
= dir
->i_sb
;
233 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
234 struct inode
*inode
= dentry
->d_inode
;
235 struct f2fs_dir_entry
*de
;
240 trace_f2fs_unlink_enter(dir
, dentry
);
241 f2fs_balance_fs(sbi
);
243 de
= f2fs_find_entry(dir
, &dentry
->d_name
, &page
);
247 err
= check_orphan_space(sbi
);
250 f2fs_put_page(page
, 0);
254 ilock
= mutex_lock_op(sbi
);
255 f2fs_delete_entry(de
, page
, inode
);
256 mutex_unlock_op(sbi
, ilock
);
258 /* In order to evict this inode, we set it dirty */
259 mark_inode_dirty(inode
);
261 trace_f2fs_unlink_exit(inode
, err
);
265 static int f2fs_symlink(struct inode
*dir
, struct dentry
*dentry
,
268 struct super_block
*sb
= dir
->i_sb
;
269 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
271 size_t symlen
= strlen(symname
) + 1;
274 f2fs_balance_fs(sbi
);
276 inode
= f2fs_new_inode(dir
, S_IFLNK
| S_IRWXUGO
);
278 return PTR_ERR(inode
);
280 inode
->i_op
= &f2fs_symlink_inode_operations
;
281 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
283 ilock
= mutex_lock_op(sbi
);
284 err
= f2fs_add_link(dentry
, inode
);
285 mutex_unlock_op(sbi
, ilock
);
289 err
= page_symlink(inode
, symname
, symlen
);
290 alloc_nid_done(sbi
, inode
->i_ino
);
292 d_instantiate(dentry
, inode
);
293 unlock_new_inode(inode
);
297 unlock_new_inode(inode
);
299 alloc_nid_failed(sbi
, inode
->i_ino
);
303 static int f2fs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
305 struct f2fs_sb_info
*sbi
= F2FS_SB(dir
->i_sb
);
309 f2fs_balance_fs(sbi
);
311 inode
= f2fs_new_inode(dir
, S_IFDIR
| mode
);
313 return PTR_ERR(inode
);
315 inode
->i_op
= &f2fs_dir_inode_operations
;
316 inode
->i_fop
= &f2fs_dir_operations
;
317 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
318 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
320 set_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
321 ilock
= mutex_lock_op(sbi
);
322 err
= f2fs_add_link(dentry
, inode
);
323 mutex_unlock_op(sbi
, ilock
);
327 alloc_nid_done(sbi
, inode
->i_ino
);
329 d_instantiate(dentry
, inode
);
330 unlock_new_inode(inode
);
335 clear_inode_flag(F2FS_I(inode
), FI_INC_LINK
);
337 unlock_new_inode(inode
);
339 alloc_nid_failed(sbi
, inode
->i_ino
);
343 static int f2fs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
345 struct inode
*inode
= dentry
->d_inode
;
346 if (f2fs_empty_dir(inode
))
347 return f2fs_unlink(dir
, dentry
);
351 static int f2fs_mknod(struct inode
*dir
, struct dentry
*dentry
,
352 umode_t mode
, dev_t rdev
)
354 struct super_block
*sb
= dir
->i_sb
;
355 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
360 if (!new_valid_dev(rdev
))
363 f2fs_balance_fs(sbi
);
365 inode
= f2fs_new_inode(dir
, mode
);
367 return PTR_ERR(inode
);
369 init_special_inode(inode
, inode
->i_mode
, rdev
);
370 inode
->i_op
= &f2fs_special_inode_operations
;
372 ilock
= mutex_lock_op(sbi
);
373 err
= f2fs_add_link(dentry
, inode
);
374 mutex_unlock_op(sbi
, ilock
);
378 alloc_nid_done(sbi
, inode
->i_ino
);
379 d_instantiate(dentry
, inode
);
380 unlock_new_inode(inode
);
384 unlock_new_inode(inode
);
386 alloc_nid_failed(sbi
, inode
->i_ino
);
390 static int f2fs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
391 struct inode
*new_dir
, struct dentry
*new_dentry
)
393 struct super_block
*sb
= old_dir
->i_sb
;
394 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
395 struct inode
*old_inode
= old_dentry
->d_inode
;
396 struct inode
*new_inode
= new_dentry
->d_inode
;
397 struct page
*old_dir_page
;
398 struct page
*old_page
;
399 struct f2fs_dir_entry
*old_dir_entry
= NULL
;
400 struct f2fs_dir_entry
*old_entry
;
401 struct f2fs_dir_entry
*new_entry
;
402 int err
= -ENOENT
, ilock
= -1;
404 f2fs_balance_fs(sbi
);
406 old_entry
= f2fs_find_entry(old_dir
, &old_dentry
->d_name
, &old_page
);
410 if (S_ISDIR(old_inode
->i_mode
)) {
412 old_dir_entry
= f2fs_parent_dir(old_inode
, &old_dir_page
);
417 ilock
= mutex_lock_op(sbi
);
420 struct page
*new_page
;
423 if (old_dir_entry
&& !f2fs_empty_dir(new_inode
))
427 new_entry
= f2fs_find_entry(new_dir
, &new_dentry
->d_name
,
432 f2fs_set_link(new_dir
, new_entry
, new_page
, old_inode
);
434 new_inode
->i_ctime
= CURRENT_TIME
;
436 drop_nlink(new_inode
);
437 drop_nlink(new_inode
);
438 if (!new_inode
->i_nlink
)
439 add_orphan_inode(sbi
, new_inode
->i_ino
);
440 update_inode_page(new_inode
);
442 err
= f2fs_add_link(new_dentry
, old_inode
);
448 update_inode_page(new_dir
);
452 old_inode
->i_ctime
= CURRENT_TIME
;
453 mark_inode_dirty(old_inode
);
455 f2fs_delete_entry(old_entry
, old_page
, NULL
);
458 if (old_dir
!= new_dir
) {
459 f2fs_set_link(old_inode
, old_dir_entry
,
460 old_dir_page
, new_dir
);
462 kunmap(old_dir_page
);
463 f2fs_put_page(old_dir_page
, 0);
466 update_inode_page(old_dir
);
469 mutex_unlock_op(sbi
, ilock
);
474 kunmap(old_dir_page
);
475 f2fs_put_page(old_dir_page
, 0);
477 mutex_unlock_op(sbi
, ilock
);
480 f2fs_put_page(old_page
, 0);
485 const struct inode_operations f2fs_dir_inode_operations
= {
486 .create
= f2fs_create
,
487 .lookup
= f2fs_lookup
,
489 .unlink
= f2fs_unlink
,
490 .symlink
= f2fs_symlink
,
494 .rename
= f2fs_rename
,
495 .setattr
= f2fs_setattr
,
496 .get_acl
= f2fs_get_acl
,
497 #ifdef CONFIG_F2FS_FS_XATTR
498 .setxattr
= generic_setxattr
,
499 .getxattr
= generic_getxattr
,
500 .listxattr
= f2fs_listxattr
,
501 .removexattr
= generic_removexattr
,
505 const struct inode_operations f2fs_symlink_inode_operations
= {
506 .readlink
= generic_readlink
,
507 .follow_link
= page_follow_link_light
,
508 .put_link
= page_put_link
,
509 .setattr
= f2fs_setattr
,
510 #ifdef CONFIG_F2FS_FS_XATTR
511 .setxattr
= generic_setxattr
,
512 .getxattr
= generic_getxattr
,
513 .listxattr
= f2fs_listxattr
,
514 .removexattr
= generic_removexattr
,
518 const struct inode_operations f2fs_special_inode_operations
= {
519 .setattr
= f2fs_setattr
,
520 .get_acl
= f2fs_get_acl
,
521 #ifdef CONFIG_F2FS_FS_XATTR
522 .setxattr
= generic_setxattr
,
523 .getxattr
= generic_getxattr
,
524 .listxattr
= f2fs_listxattr
,
525 .removexattr
= generic_removexattr
,