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, ilock; 31 32 inode = new_inode(sb); 33 if (!inode) 34 return ERR_PTR(-ENOMEM); 35 36 ilock = mutex_lock_op(sbi); 37 if (!alloc_nid(sbi, &ino)) { 38 mutex_unlock_op(sbi, ilock); 39 err = -ENOSPC; 40 goto fail; 41 } 42 mutex_unlock_op(sbi, ilock); 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, ilock; 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 ilock = mutex_lock_op(sbi); 135 err = f2fs_add_link(dentry, inode); 136 mutex_unlock_op(sbi, ilock); 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, ilock; 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 ilock = mutex_lock_op(sbi); 169 err = f2fs_add_link(dentry, inode); 170 mutex_unlock_op(sbi, ilock); 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 int ilock; 224 225 trace_f2fs_unlink_enter(dir, dentry); 226 f2fs_balance_fs(sbi); 227 228 de = f2fs_find_entry(dir, &dentry->d_name, &page); 229 if (!de) 230 goto fail; 231 232 err = acquire_orphan_inode(sbi); 233 if (err) { 234 kunmap(page); 235 f2fs_put_page(page, 0); 236 goto fail; 237 } 238 239 ilock = mutex_lock_op(sbi); 240 f2fs_delete_entry(de, page, inode); 241 mutex_unlock_op(sbi, ilock); 242 243 /* In order to evict this inode, we set it dirty */ 244 mark_inode_dirty(inode); 245 fail: 246 trace_f2fs_unlink_exit(inode, err); 247 return err; 248 } 249 250 static int f2fs_symlink(struct inode *dir, struct dentry *dentry, 251 const char *symname) 252 { 253 struct super_block *sb = dir->i_sb; 254 struct f2fs_sb_info *sbi = F2FS_SB(sb); 255 struct inode *inode; 256 size_t symlen = strlen(symname) + 1; 257 int err, ilock; 258 259 f2fs_balance_fs(sbi); 260 261 inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO); 262 if (IS_ERR(inode)) 263 return PTR_ERR(inode); 264 265 inode->i_op = &f2fs_symlink_inode_operations; 266 inode->i_mapping->a_ops = &f2fs_dblock_aops; 267 268 ilock = mutex_lock_op(sbi); 269 err = f2fs_add_link(dentry, inode); 270 mutex_unlock_op(sbi, ilock); 271 if (err) 272 goto out; 273 274 err = page_symlink(inode, symname, symlen); 275 alloc_nid_done(sbi, inode->i_ino); 276 277 d_instantiate(dentry, inode); 278 unlock_new_inode(inode); 279 return err; 280 out: 281 clear_nlink(inode); 282 unlock_new_inode(inode); 283 make_bad_inode(inode); 284 iput(inode); 285 alloc_nid_failed(sbi, inode->i_ino); 286 return err; 287 } 288 289 static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 290 { 291 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 292 struct inode *inode; 293 int err, ilock; 294 295 f2fs_balance_fs(sbi); 296 297 inode = f2fs_new_inode(dir, S_IFDIR | mode); 298 if (IS_ERR(inode)) 299 return PTR_ERR(inode); 300 301 inode->i_op = &f2fs_dir_inode_operations; 302 inode->i_fop = &f2fs_dir_operations; 303 inode->i_mapping->a_ops = &f2fs_dblock_aops; 304 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); 305 306 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 307 ilock = mutex_lock_op(sbi); 308 err = f2fs_add_link(dentry, inode); 309 mutex_unlock_op(sbi, ilock); 310 if (err) 311 goto out_fail; 312 313 alloc_nid_done(sbi, inode->i_ino); 314 315 d_instantiate(dentry, inode); 316 unlock_new_inode(inode); 317 318 return 0; 319 320 out_fail: 321 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 322 clear_nlink(inode); 323 unlock_new_inode(inode); 324 make_bad_inode(inode); 325 iput(inode); 326 alloc_nid_failed(sbi, inode->i_ino); 327 return err; 328 } 329 330 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry) 331 { 332 struct inode *inode = dentry->d_inode; 333 if (f2fs_empty_dir(inode)) 334 return f2fs_unlink(dir, dentry); 335 return -ENOTEMPTY; 336 } 337 338 static int f2fs_mknod(struct inode *dir, struct dentry *dentry, 339 umode_t mode, dev_t rdev) 340 { 341 struct super_block *sb = dir->i_sb; 342 struct f2fs_sb_info *sbi = F2FS_SB(sb); 343 struct inode *inode; 344 int err = 0; 345 int ilock; 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 ilock = mutex_lock_op(sbi); 360 err = f2fs_add_link(dentry, inode); 361 mutex_unlock_op(sbi, ilock); 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, ilock = -1; 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 ilock = mutex_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 430 new_inode->i_ctime = CURRENT_TIME; 431 if (old_dir_entry) 432 drop_nlink(new_inode); 433 drop_nlink(new_inode); 434 435 if (!new_inode->i_nlink) 436 add_orphan_inode(sbi, new_inode->i_ino); 437 else 438 release_orphan_inode(sbi); 439 440 update_inode_page(old_inode); 441 update_inode_page(new_inode); 442 } else { 443 err = f2fs_add_link(new_dentry, old_inode); 444 if (err) 445 goto out_dir; 446 447 if (old_dir_entry) { 448 inc_nlink(new_dir); 449 update_inode_page(new_dir); 450 } 451 } 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 } else { 463 kunmap(old_dir_page); 464 f2fs_put_page(old_dir_page, 0); 465 } 466 drop_nlink(old_dir); 467 update_inode_page(old_dir); 468 } 469 470 mutex_unlock_op(sbi, ilock); 471 return 0; 472 473 put_out_dir: 474 f2fs_put_page(new_page, 1); 475 out_dir: 476 if (old_dir_entry) { 477 kunmap(old_dir_page); 478 f2fs_put_page(old_dir_page, 0); 479 } 480 mutex_unlock_op(sbi, ilock); 481 out_old: 482 kunmap(old_page); 483 f2fs_put_page(old_page, 0); 484 out: 485 return err; 486 } 487 488 const struct inode_operations f2fs_dir_inode_operations = { 489 .create = f2fs_create, 490 .lookup = f2fs_lookup, 491 .link = f2fs_link, 492 .unlink = f2fs_unlink, 493 .symlink = f2fs_symlink, 494 .mkdir = f2fs_mkdir, 495 .rmdir = f2fs_rmdir, 496 .mknod = f2fs_mknod, 497 .rename = f2fs_rename, 498 .getattr = f2fs_getattr, 499 .setattr = f2fs_setattr, 500 .get_acl = f2fs_get_acl, 501 #ifdef CONFIG_F2FS_FS_XATTR 502 .setxattr = generic_setxattr, 503 .getxattr = generic_getxattr, 504 .listxattr = f2fs_listxattr, 505 .removexattr = generic_removexattr, 506 #endif 507 }; 508 509 const struct inode_operations f2fs_symlink_inode_operations = { 510 .readlink = generic_readlink, 511 .follow_link = page_follow_link_light, 512 .put_link = page_put_link, 513 .getattr = f2fs_getattr, 514 .setattr = f2fs_setattr, 515 #ifdef CONFIG_F2FS_FS_XATTR 516 .setxattr = generic_setxattr, 517 .getxattr = generic_getxattr, 518 .listxattr = f2fs_listxattr, 519 .removexattr = generic_removexattr, 520 #endif 521 }; 522 523 const struct inode_operations f2fs_special_inode_operations = { 524 .getattr = f2fs_getattr, 525 .setattr = f2fs_setattr, 526 .get_acl = f2fs_get_acl, 527 #ifdef CONFIG_F2FS_FS_XATTR 528 .setxattr = generic_setxattr, 529 .getxattr = generic_getxattr, 530 .listxattr = f2fs_listxattr, 531 .removexattr = generic_removexattr, 532 #endif 533 }; 534