1 /* 2 * fs/f2fs/namei.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/pagemap.h> 14 #include <linux/sched.h> 15 #include <linux/ctype.h> 16 #include <linux/dcache.h> 17 18 #include "f2fs.h" 19 #include "node.h" 20 #include "xattr.h" 21 #include "acl.h" 22 #include <trace/events/f2fs.h> 23 24 static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode) 25 { 26 struct super_block *sb = dir->i_sb; 27 struct f2fs_sb_info *sbi = F2FS_SB(sb); 28 nid_t ino; 29 struct inode *inode; 30 bool nid_free = false; 31 int err; 32 33 inode = new_inode(sb); 34 if (!inode) 35 return ERR_PTR(-ENOMEM); 36 37 f2fs_lock_op(sbi); 38 if (!alloc_nid(sbi, &ino)) { 39 f2fs_unlock_op(sbi); 40 err = -ENOSPC; 41 goto fail; 42 } 43 f2fs_unlock_op(sbi); 44 45 inode_init_owner(inode, dir, mode); 46 47 inode->i_ino = ino; 48 inode->i_blocks = 0; 49 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 50 inode->i_generation = sbi->s_next_generation++; 51 52 err = insert_inode_locked(inode); 53 if (err) { 54 err = -EINVAL; 55 nid_free = true; 56 goto out; 57 } 58 trace_f2fs_new_inode(inode, 0); 59 mark_inode_dirty(inode); 60 return inode; 61 62 out: 63 clear_nlink(inode); 64 unlock_new_inode(inode); 65 fail: 66 trace_f2fs_new_inode(inode, err); 67 make_bad_inode(inode); 68 iput(inode); 69 if (nid_free) 70 alloc_nid_failed(sbi, ino); 71 return ERR_PTR(err); 72 } 73 74 static int is_multimedia_file(const unsigned char *s, const char *sub) 75 { 76 size_t slen = strlen(s); 77 size_t sublen = strlen(sub); 78 79 if (sublen > slen) 80 return 0; 81 82 return !strncasecmp(s + slen - sublen, sub, sublen); 83 } 84 85 /* 86 * Set multimedia files as cold files for hot/cold data separation 87 */ 88 static inline void set_cold_files(struct f2fs_sb_info *sbi, struct inode *inode, 89 const unsigned char *name) 90 { 91 int i; 92 __u8 (*extlist)[8] = sbi->raw_super->extension_list; 93 94 int count = le32_to_cpu(sbi->raw_super->extension_count); 95 for (i = 0; i < count; i++) { 96 if (is_multimedia_file(name, extlist[i])) { 97 file_set_cold(inode); 98 break; 99 } 100 } 101 } 102 103 static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 104 bool excl) 105 { 106 struct super_block *sb = dir->i_sb; 107 struct f2fs_sb_info *sbi = F2FS_SB(sb); 108 struct inode *inode; 109 nid_t ino = 0; 110 int err; 111 112 f2fs_balance_fs(sbi); 113 114 inode = f2fs_new_inode(dir, mode); 115 if (IS_ERR(inode)) 116 return PTR_ERR(inode); 117 118 if (!test_opt(sbi, DISABLE_EXT_IDENTIFY)) 119 set_cold_files(sbi, inode, dentry->d_name.name); 120 121 inode->i_op = &f2fs_file_inode_operations; 122 inode->i_fop = &f2fs_file_operations; 123 inode->i_mapping->a_ops = &f2fs_dblock_aops; 124 ino = inode->i_ino; 125 126 f2fs_lock_op(sbi); 127 err = f2fs_add_link(dentry, inode); 128 f2fs_unlock_op(sbi); 129 if (err) 130 goto out; 131 132 alloc_nid_done(sbi, ino); 133 134 d_instantiate(dentry, inode); 135 unlock_new_inode(inode); 136 return 0; 137 out: 138 clear_nlink(inode); 139 unlock_new_inode(inode); 140 make_bad_inode(inode); 141 iput(inode); 142 alloc_nid_failed(sbi, ino); 143 return err; 144 } 145 146 static int f2fs_link(struct dentry *old_dentry, struct inode *dir, 147 struct dentry *dentry) 148 { 149 struct inode *inode = old_dentry->d_inode; 150 struct super_block *sb = dir->i_sb; 151 struct f2fs_sb_info *sbi = F2FS_SB(sb); 152 int err; 153 154 f2fs_balance_fs(sbi); 155 156 inode->i_ctime = CURRENT_TIME; 157 ihold(inode); 158 159 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 160 f2fs_lock_op(sbi); 161 err = f2fs_add_link(dentry, inode); 162 f2fs_unlock_op(sbi); 163 if (err) 164 goto out; 165 166 d_instantiate(dentry, inode); 167 return 0; 168 out: 169 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 170 iput(inode); 171 return err; 172 } 173 174 struct dentry *f2fs_get_parent(struct dentry *child) 175 { 176 struct qstr dotdot = QSTR_INIT("..", 2); 177 unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot); 178 if (!ino) 179 return ERR_PTR(-ENOENT); 180 return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino)); 181 } 182 183 static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, 184 unsigned int flags) 185 { 186 struct inode *inode = NULL; 187 struct f2fs_dir_entry *de; 188 struct page *page; 189 190 if (dentry->d_name.len > F2FS_NAME_LEN) 191 return ERR_PTR(-ENAMETOOLONG); 192 193 de = f2fs_find_entry(dir, &dentry->d_name, &page); 194 if (de) { 195 nid_t ino = le32_to_cpu(de->ino); 196 kunmap(page); 197 f2fs_put_page(page, 0); 198 199 inode = f2fs_iget(dir->i_sb, ino); 200 if (IS_ERR(inode)) 201 return ERR_CAST(inode); 202 203 stat_inc_inline_inode(inode); 204 } 205 206 return d_splice_alias(inode, dentry); 207 } 208 209 static int f2fs_unlink(struct inode *dir, struct dentry *dentry) 210 { 211 struct super_block *sb = dir->i_sb; 212 struct f2fs_sb_info *sbi = F2FS_SB(sb); 213 struct inode *inode = dentry->d_inode; 214 struct f2fs_dir_entry *de; 215 struct page *page; 216 int err = -ENOENT; 217 218 trace_f2fs_unlink_enter(dir, dentry); 219 f2fs_balance_fs(sbi); 220 221 de = f2fs_find_entry(dir, &dentry->d_name, &page); 222 if (!de) 223 goto fail; 224 225 f2fs_lock_op(sbi); 226 err = acquire_orphan_inode(sbi); 227 if (err) { 228 f2fs_unlock_op(sbi); 229 kunmap(page); 230 f2fs_put_page(page, 0); 231 goto fail; 232 } 233 f2fs_delete_entry(de, page, inode); 234 f2fs_unlock_op(sbi); 235 236 /* In order to evict this inode, we set it dirty */ 237 mark_inode_dirty(inode); 238 fail: 239 trace_f2fs_unlink_exit(inode, err); 240 return err; 241 } 242 243 static int f2fs_symlink(struct inode *dir, struct dentry *dentry, 244 const char *symname) 245 { 246 struct super_block *sb = dir->i_sb; 247 struct f2fs_sb_info *sbi = F2FS_SB(sb); 248 struct inode *inode; 249 size_t symlen = strlen(symname) + 1; 250 int err; 251 252 f2fs_balance_fs(sbi); 253 254 inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO); 255 if (IS_ERR(inode)) 256 return PTR_ERR(inode); 257 258 inode->i_op = &f2fs_symlink_inode_operations; 259 inode->i_mapping->a_ops = &f2fs_dblock_aops; 260 261 f2fs_lock_op(sbi); 262 err = f2fs_add_link(dentry, inode); 263 f2fs_unlock_op(sbi); 264 if (err) 265 goto out; 266 267 err = page_symlink(inode, symname, symlen); 268 alloc_nid_done(sbi, inode->i_ino); 269 270 d_instantiate(dentry, inode); 271 unlock_new_inode(inode); 272 return err; 273 out: 274 clear_nlink(inode); 275 unlock_new_inode(inode); 276 make_bad_inode(inode); 277 iput(inode); 278 alloc_nid_failed(sbi, inode->i_ino); 279 return err; 280 } 281 282 static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 283 { 284 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 285 struct inode *inode; 286 int err; 287 288 f2fs_balance_fs(sbi); 289 290 inode = f2fs_new_inode(dir, S_IFDIR | mode); 291 if (IS_ERR(inode)) 292 return PTR_ERR(inode); 293 294 inode->i_op = &f2fs_dir_inode_operations; 295 inode->i_fop = &f2fs_dir_operations; 296 inode->i_mapping->a_ops = &f2fs_dblock_aops; 297 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); 298 299 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 300 f2fs_lock_op(sbi); 301 err = f2fs_add_link(dentry, inode); 302 f2fs_unlock_op(sbi); 303 if (err) 304 goto out_fail; 305 306 alloc_nid_done(sbi, inode->i_ino); 307 308 d_instantiate(dentry, inode); 309 unlock_new_inode(inode); 310 311 return 0; 312 313 out_fail: 314 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 315 clear_nlink(inode); 316 unlock_new_inode(inode); 317 make_bad_inode(inode); 318 iput(inode); 319 alloc_nid_failed(sbi, inode->i_ino); 320 return err; 321 } 322 323 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry) 324 { 325 struct inode *inode = dentry->d_inode; 326 if (f2fs_empty_dir(inode)) 327 return f2fs_unlink(dir, dentry); 328 return -ENOTEMPTY; 329 } 330 331 static int f2fs_mknod(struct inode *dir, struct dentry *dentry, 332 umode_t mode, dev_t rdev) 333 { 334 struct super_block *sb = dir->i_sb; 335 struct f2fs_sb_info *sbi = F2FS_SB(sb); 336 struct inode *inode; 337 int err = 0; 338 339 if (!new_valid_dev(rdev)) 340 return -EINVAL; 341 342 f2fs_balance_fs(sbi); 343 344 inode = f2fs_new_inode(dir, mode); 345 if (IS_ERR(inode)) 346 return PTR_ERR(inode); 347 348 init_special_inode(inode, inode->i_mode, rdev); 349 inode->i_op = &f2fs_special_inode_operations; 350 351 f2fs_lock_op(sbi); 352 err = f2fs_add_link(dentry, inode); 353 f2fs_unlock_op(sbi); 354 if (err) 355 goto out; 356 357 alloc_nid_done(sbi, inode->i_ino); 358 d_instantiate(dentry, inode); 359 unlock_new_inode(inode); 360 return 0; 361 out: 362 clear_nlink(inode); 363 unlock_new_inode(inode); 364 make_bad_inode(inode); 365 iput(inode); 366 alloc_nid_failed(sbi, inode->i_ino); 367 return err; 368 } 369 370 static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry, 371 struct inode *new_dir, struct dentry *new_dentry) 372 { 373 struct super_block *sb = old_dir->i_sb; 374 struct f2fs_sb_info *sbi = F2FS_SB(sb); 375 struct inode *old_inode = old_dentry->d_inode; 376 struct inode *new_inode = new_dentry->d_inode; 377 struct page *old_dir_page; 378 struct page *old_page, *new_page; 379 struct f2fs_dir_entry *old_dir_entry = NULL; 380 struct f2fs_dir_entry *old_entry; 381 struct f2fs_dir_entry *new_entry; 382 int err = -ENOENT; 383 384 f2fs_balance_fs(sbi); 385 386 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 387 if (!old_entry) 388 goto out; 389 390 if (S_ISDIR(old_inode->i_mode)) { 391 err = -EIO; 392 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page); 393 if (!old_dir_entry) 394 goto out_old; 395 } 396 397 f2fs_lock_op(sbi); 398 399 if (new_inode) { 400 401 err = -ENOTEMPTY; 402 if (old_dir_entry && !f2fs_empty_dir(new_inode)) 403 goto out_dir; 404 405 err = -ENOENT; 406 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, 407 &new_page); 408 if (!new_entry) 409 goto out_dir; 410 411 err = acquire_orphan_inode(sbi); 412 if (err) 413 goto put_out_dir; 414 415 if (update_dent_inode(old_inode, &new_dentry->d_name)) { 416 release_orphan_inode(sbi); 417 goto put_out_dir; 418 } 419 420 f2fs_set_link(new_dir, new_entry, new_page, old_inode); 421 422 new_inode->i_ctime = CURRENT_TIME; 423 down_write(&F2FS_I(new_inode)->i_sem); 424 if (old_dir_entry) 425 drop_nlink(new_inode); 426 drop_nlink(new_inode); 427 up_write(&F2FS_I(new_inode)->i_sem); 428 429 mark_inode_dirty(new_inode); 430 431 if (!new_inode->i_nlink) 432 add_orphan_inode(sbi, new_inode->i_ino); 433 else 434 release_orphan_inode(sbi); 435 436 update_inode_page(old_inode); 437 update_inode_page(new_inode); 438 } else { 439 err = f2fs_add_link(new_dentry, old_inode); 440 if (err) 441 goto out_dir; 442 443 if (old_dir_entry) { 444 inc_nlink(new_dir); 445 update_inode_page(new_dir); 446 } 447 } 448 449 down_write(&F2FS_I(old_inode)->i_sem); 450 file_lost_pino(old_inode); 451 up_write(&F2FS_I(old_inode)->i_sem); 452 453 old_inode->i_ctime = CURRENT_TIME; 454 mark_inode_dirty(old_inode); 455 456 f2fs_delete_entry(old_entry, old_page, NULL); 457 458 if (old_dir_entry) { 459 if (old_dir != new_dir) { 460 f2fs_set_link(old_inode, old_dir_entry, 461 old_dir_page, new_dir); 462 update_inode_page(old_inode); 463 } else { 464 kunmap(old_dir_page); 465 f2fs_put_page(old_dir_page, 0); 466 } 467 drop_nlink(old_dir); 468 mark_inode_dirty(old_dir); 469 update_inode_page(old_dir); 470 } 471 472 f2fs_unlock_op(sbi); 473 return 0; 474 475 put_out_dir: 476 kunmap(new_page); 477 f2fs_put_page(new_page, 0); 478 out_dir: 479 if (old_dir_entry) { 480 kunmap(old_dir_page); 481 f2fs_put_page(old_dir_page, 0); 482 } 483 f2fs_unlock_op(sbi); 484 out_old: 485 kunmap(old_page); 486 f2fs_put_page(old_page, 0); 487 out: 488 return err; 489 } 490 491 static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 492 { 493 struct super_block *sb = dir->i_sb; 494 struct f2fs_sb_info *sbi = F2FS_SB(sb); 495 struct inode *inode; 496 int err; 497 498 inode = f2fs_new_inode(dir, mode); 499 if (IS_ERR(inode)) 500 return PTR_ERR(inode); 501 502 inode->i_op = &f2fs_file_inode_operations; 503 inode->i_fop = &f2fs_file_operations; 504 inode->i_mapping->a_ops = &f2fs_dblock_aops; 505 506 f2fs_lock_op(sbi); 507 err = acquire_orphan_inode(sbi); 508 if (err) 509 goto out; 510 511 err = f2fs_do_tmpfile(inode, dir); 512 if (err) 513 goto release_out; 514 515 /* 516 * add this non-linked tmpfile to orphan list, in this way we could 517 * remove all unused data of tmpfile after abnormal power-off. 518 */ 519 add_orphan_inode(sbi, inode->i_ino); 520 f2fs_unlock_op(sbi); 521 522 alloc_nid_done(sbi, inode->i_ino); 523 d_tmpfile(dentry, inode); 524 unlock_new_inode(inode); 525 return 0; 526 527 release_out: 528 release_orphan_inode(sbi); 529 out: 530 f2fs_unlock_op(sbi); 531 clear_nlink(inode); 532 unlock_new_inode(inode); 533 make_bad_inode(inode); 534 iput(inode); 535 alloc_nid_failed(sbi, inode->i_ino); 536 return err; 537 } 538 539 const struct inode_operations f2fs_dir_inode_operations = { 540 .create = f2fs_create, 541 .lookup = f2fs_lookup, 542 .link = f2fs_link, 543 .unlink = f2fs_unlink, 544 .symlink = f2fs_symlink, 545 .mkdir = f2fs_mkdir, 546 .rmdir = f2fs_rmdir, 547 .mknod = f2fs_mknod, 548 .rename = f2fs_rename, 549 .tmpfile = f2fs_tmpfile, 550 .getattr = f2fs_getattr, 551 .setattr = f2fs_setattr, 552 .get_acl = f2fs_get_acl, 553 .set_acl = f2fs_set_acl, 554 #ifdef CONFIG_F2FS_FS_XATTR 555 .setxattr = generic_setxattr, 556 .getxattr = generic_getxattr, 557 .listxattr = f2fs_listxattr, 558 .removexattr = generic_removexattr, 559 #endif 560 }; 561 562 const struct inode_operations f2fs_symlink_inode_operations = { 563 .readlink = generic_readlink, 564 .follow_link = page_follow_link_light, 565 .put_link = page_put_link, 566 .getattr = f2fs_getattr, 567 .setattr = f2fs_setattr, 568 #ifdef CONFIG_F2FS_FS_XATTR 569 .setxattr = generic_setxattr, 570 .getxattr = generic_getxattr, 571 .listxattr = f2fs_listxattr, 572 .removexattr = generic_removexattr, 573 #endif 574 }; 575 576 const struct inode_operations f2fs_special_inode_operations = { 577 .getattr = f2fs_getattr, 578 .setattr = f2fs_setattr, 579 .get_acl = f2fs_get_acl, 580 .set_acl = f2fs_set_acl, 581 #ifdef CONFIG_F2FS_FS_XATTR 582 .setxattr = generic_setxattr, 583 .getxattr = generic_getxattr, 584 .listxattr = f2fs_listxattr, 585 .removexattr = generic_removexattr, 586 #endif 587 }; 588