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