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 212 return d_splice_alias(inode, dentry); 213 } 214 215 static int f2fs_unlink(struct inode *dir, struct dentry *dentry) 216 { 217 struct super_block *sb = dir->i_sb; 218 struct f2fs_sb_info *sbi = F2FS_SB(sb); 219 struct inode *inode = dentry->d_inode; 220 struct f2fs_dir_entry *de; 221 struct page *page; 222 int err = -ENOENT; 223 224 trace_f2fs_unlink_enter(dir, dentry); 225 f2fs_balance_fs(sbi); 226 227 de = f2fs_find_entry(dir, &dentry->d_name, &page); 228 if (!de) 229 goto fail; 230 231 f2fs_lock_op(sbi); 232 err = acquire_orphan_inode(sbi); 233 if (err) { 234 f2fs_unlock_op(sbi); 235 kunmap(page); 236 f2fs_put_page(page, 0); 237 goto fail; 238 } 239 f2fs_delete_entry(de, page, inode); 240 f2fs_unlock_op(sbi); 241 242 /* In order to evict this inode, we set it dirty */ 243 mark_inode_dirty(inode); 244 fail: 245 trace_f2fs_unlink_exit(inode, err); 246 return err; 247 } 248 249 static int f2fs_symlink(struct inode *dir, struct dentry *dentry, 250 const char *symname) 251 { 252 struct super_block *sb = dir->i_sb; 253 struct f2fs_sb_info *sbi = F2FS_SB(sb); 254 struct inode *inode; 255 size_t symlen = strlen(symname) + 1; 256 int err; 257 258 f2fs_balance_fs(sbi); 259 260 inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO); 261 if (IS_ERR(inode)) 262 return PTR_ERR(inode); 263 264 inode->i_op = &f2fs_symlink_inode_operations; 265 inode->i_mapping->a_ops = &f2fs_dblock_aops; 266 267 f2fs_lock_op(sbi); 268 err = f2fs_add_link(dentry, inode); 269 f2fs_unlock_op(sbi); 270 if (err) 271 goto out; 272 273 err = page_symlink(inode, symname, symlen); 274 alloc_nid_done(sbi, inode->i_ino); 275 276 d_instantiate(dentry, inode); 277 unlock_new_inode(inode); 278 return err; 279 out: 280 clear_nlink(inode); 281 unlock_new_inode(inode); 282 make_bad_inode(inode); 283 iput(inode); 284 alloc_nid_failed(sbi, inode->i_ino); 285 return err; 286 } 287 288 static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 289 { 290 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 291 struct inode *inode; 292 int err; 293 294 f2fs_balance_fs(sbi); 295 296 inode = f2fs_new_inode(dir, S_IFDIR | mode); 297 if (IS_ERR(inode)) 298 return PTR_ERR(inode); 299 300 inode->i_op = &f2fs_dir_inode_operations; 301 inode->i_fop = &f2fs_dir_operations; 302 inode->i_mapping->a_ops = &f2fs_dblock_aops; 303 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); 304 305 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 306 f2fs_lock_op(sbi); 307 err = f2fs_add_link(dentry, inode); 308 f2fs_unlock_op(sbi); 309 if (err) 310 goto out_fail; 311 312 alloc_nid_done(sbi, inode->i_ino); 313 314 d_instantiate(dentry, inode); 315 unlock_new_inode(inode); 316 317 return 0; 318 319 out_fail: 320 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 321 clear_nlink(inode); 322 unlock_new_inode(inode); 323 make_bad_inode(inode); 324 iput(inode); 325 alloc_nid_failed(sbi, inode->i_ino); 326 return err; 327 } 328 329 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry) 330 { 331 struct inode *inode = dentry->d_inode; 332 if (f2fs_empty_dir(inode)) 333 return f2fs_unlink(dir, dentry); 334 return -ENOTEMPTY; 335 } 336 337 static int f2fs_mknod(struct inode *dir, struct dentry *dentry, 338 umode_t mode, dev_t rdev) 339 { 340 struct super_block *sb = dir->i_sb; 341 struct f2fs_sb_info *sbi = F2FS_SB(sb); 342 struct inode *inode; 343 int err = 0; 344 345 if (!new_valid_dev(rdev)) 346 return -EINVAL; 347 348 f2fs_balance_fs(sbi); 349 350 inode = f2fs_new_inode(dir, mode); 351 if (IS_ERR(inode)) 352 return PTR_ERR(inode); 353 354 init_special_inode(inode, inode->i_mode, rdev); 355 inode->i_op = &f2fs_special_inode_operations; 356 357 f2fs_lock_op(sbi); 358 err = f2fs_add_link(dentry, inode); 359 f2fs_unlock_op(sbi); 360 if (err) 361 goto out; 362 363 alloc_nid_done(sbi, inode->i_ino); 364 d_instantiate(dentry, inode); 365 unlock_new_inode(inode); 366 return 0; 367 out: 368 clear_nlink(inode); 369 unlock_new_inode(inode); 370 make_bad_inode(inode); 371 iput(inode); 372 alloc_nid_failed(sbi, inode->i_ino); 373 return err; 374 } 375 376 static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry, 377 struct inode *new_dir, struct dentry *new_dentry) 378 { 379 struct super_block *sb = old_dir->i_sb; 380 struct f2fs_sb_info *sbi = F2FS_SB(sb); 381 struct inode *old_inode = old_dentry->d_inode; 382 struct inode *new_inode = new_dentry->d_inode; 383 struct page *old_dir_page; 384 struct page *old_page, *new_page; 385 struct f2fs_dir_entry *old_dir_entry = NULL; 386 struct f2fs_dir_entry *old_entry; 387 struct f2fs_dir_entry *new_entry; 388 int err = -ENOENT; 389 390 f2fs_balance_fs(sbi); 391 392 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 393 if (!old_entry) 394 goto out; 395 396 if (S_ISDIR(old_inode->i_mode)) { 397 err = -EIO; 398 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page); 399 if (!old_dir_entry) 400 goto out_old; 401 } 402 403 f2fs_lock_op(sbi); 404 405 if (new_inode) { 406 407 err = -ENOTEMPTY; 408 if (old_dir_entry && !f2fs_empty_dir(new_inode)) 409 goto out_dir; 410 411 err = -ENOENT; 412 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, 413 &new_page); 414 if (!new_entry) 415 goto out_dir; 416 417 err = acquire_orphan_inode(sbi); 418 if (err) 419 goto put_out_dir; 420 421 if (update_dent_inode(old_inode, &new_dentry->d_name)) { 422 release_orphan_inode(sbi); 423 goto put_out_dir; 424 } 425 426 f2fs_set_link(new_dir, new_entry, new_page, old_inode); 427 428 new_inode->i_ctime = CURRENT_TIME; 429 if (old_dir_entry) 430 drop_nlink(new_inode); 431 drop_nlink(new_inode); 432 433 if (!new_inode->i_nlink) 434 add_orphan_inode(sbi, new_inode->i_ino); 435 else 436 release_orphan_inode(sbi); 437 438 update_inode_page(old_inode); 439 update_inode_page(new_inode); 440 } else { 441 err = f2fs_add_link(new_dentry, old_inode); 442 if (err) 443 goto out_dir; 444 445 if (old_dir_entry) { 446 inc_nlink(new_dir); 447 update_inode_page(new_dir); 448 } 449 } 450 451 old_inode->i_ctime = CURRENT_TIME; 452 mark_inode_dirty(old_inode); 453 454 f2fs_delete_entry(old_entry, old_page, NULL); 455 456 if (old_dir_entry) { 457 if (old_dir != new_dir) { 458 f2fs_set_link(old_inode, old_dir_entry, 459 old_dir_page, new_dir); 460 } else { 461 kunmap(old_dir_page); 462 f2fs_put_page(old_dir_page, 0); 463 } 464 drop_nlink(old_dir); 465 update_inode_page(old_dir); 466 } 467 468 f2fs_unlock_op(sbi); 469 return 0; 470 471 put_out_dir: 472 f2fs_put_page(new_page, 1); 473 out_dir: 474 if (old_dir_entry) { 475 kunmap(old_dir_page); 476 f2fs_put_page(old_dir_page, 0); 477 } 478 f2fs_unlock_op(sbi); 479 out_old: 480 kunmap(old_page); 481 f2fs_put_page(old_page, 0); 482 out: 483 return err; 484 } 485 486 const struct inode_operations f2fs_dir_inode_operations = { 487 .create = f2fs_create, 488 .lookup = f2fs_lookup, 489 .link = f2fs_link, 490 .unlink = f2fs_unlink, 491 .symlink = f2fs_symlink, 492 .mkdir = f2fs_mkdir, 493 .rmdir = f2fs_rmdir, 494 .mknod = f2fs_mknod, 495 .rename = f2fs_rename, 496 .getattr = f2fs_getattr, 497 .setattr = f2fs_setattr, 498 .get_acl = f2fs_get_acl, 499 #ifdef CONFIG_F2FS_FS_XATTR 500 .setxattr = generic_setxattr, 501 .getxattr = generic_getxattr, 502 .listxattr = f2fs_listxattr, 503 .removexattr = generic_removexattr, 504 #endif 505 }; 506 507 const struct inode_operations f2fs_symlink_inode_operations = { 508 .readlink = generic_readlink, 509 .follow_link = page_follow_link_light, 510 .put_link = page_put_link, 511 .getattr = f2fs_getattr, 512 .setattr = f2fs_setattr, 513 #ifdef CONFIG_F2FS_FS_XATTR 514 .setxattr = generic_setxattr, 515 .getxattr = generic_getxattr, 516 .listxattr = f2fs_listxattr, 517 .removexattr = generic_removexattr, 518 #endif 519 }; 520 521 const struct inode_operations f2fs_special_inode_operations = { 522 .getattr = f2fs_getattr, 523 .setattr = f2fs_setattr, 524 .get_acl = f2fs_get_acl, 525 #ifdef CONFIG_F2FS_FS_XATTR 526 .setxattr = generic_setxattr, 527 .getxattr = generic_getxattr, 528 .listxattr = f2fs_listxattr, 529 .removexattr = generic_removexattr, 530 #endif 531 }; 532