1 /* 2 * fs/f2fs/inode.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/buffer_head.h> 14 #include <linux/backing-dev.h> 15 #include <linux/writeback.h> 16 17 #include "f2fs.h" 18 #include "node.h" 19 #include "segment.h" 20 21 #include <trace/events/f2fs.h> 22 23 void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) 24 { 25 if (f2fs_inode_dirtied(inode, sync)) 26 return; 27 28 mark_inode_dirty_sync(inode); 29 } 30 31 void f2fs_set_inode_flags(struct inode *inode) 32 { 33 unsigned int flags = F2FS_I(inode)->i_flags; 34 unsigned int new_fl = 0; 35 36 if (flags & FS_SYNC_FL) 37 new_fl |= S_SYNC; 38 if (flags & FS_APPEND_FL) 39 new_fl |= S_APPEND; 40 if (flags & FS_IMMUTABLE_FL) 41 new_fl |= S_IMMUTABLE; 42 if (flags & FS_NOATIME_FL) 43 new_fl |= S_NOATIME; 44 if (flags & FS_DIRSYNC_FL) 45 new_fl |= S_DIRSYNC; 46 if (f2fs_encrypted_inode(inode)) 47 new_fl |= S_ENCRYPTED; 48 inode_set_flags(inode, new_fl, 49 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC| 50 S_ENCRYPTED); 51 } 52 53 static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri) 54 { 55 int extra_size = get_extra_isize(inode); 56 57 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 58 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 59 if (ri->i_addr[extra_size]) 60 inode->i_rdev = old_decode_dev( 61 le32_to_cpu(ri->i_addr[extra_size])); 62 else 63 inode->i_rdev = new_decode_dev( 64 le32_to_cpu(ri->i_addr[extra_size + 1])); 65 } 66 } 67 68 static bool __written_first_block(struct f2fs_inode *ri) 69 { 70 block_t addr = le32_to_cpu(ri->i_addr[offset_in_addr(ri)]); 71 72 if (addr != NEW_ADDR && addr != NULL_ADDR) 73 return true; 74 return false; 75 } 76 77 static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri) 78 { 79 int extra_size = get_extra_isize(inode); 80 81 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 82 if (old_valid_dev(inode->i_rdev)) { 83 ri->i_addr[extra_size] = 84 cpu_to_le32(old_encode_dev(inode->i_rdev)); 85 ri->i_addr[extra_size + 1] = 0; 86 } else { 87 ri->i_addr[extra_size] = 0; 88 ri->i_addr[extra_size + 1] = 89 cpu_to_le32(new_encode_dev(inode->i_rdev)); 90 ri->i_addr[extra_size + 2] = 0; 91 } 92 } 93 } 94 95 static void __recover_inline_status(struct inode *inode, struct page *ipage) 96 { 97 void *inline_data = inline_data_addr(inode, ipage); 98 __le32 *start = inline_data; 99 __le32 *end = start + MAX_INLINE_DATA(inode) / sizeof(__le32); 100 101 while (start < end) { 102 if (*start++) { 103 f2fs_wait_on_page_writeback(ipage, NODE, true); 104 105 set_inode_flag(inode, FI_DATA_EXIST); 106 set_raw_inline(inode, F2FS_INODE(ipage)); 107 set_page_dirty(ipage); 108 return; 109 } 110 } 111 return; 112 } 113 114 static bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct page *page) 115 { 116 struct f2fs_inode *ri = &F2FS_NODE(page)->i; 117 int extra_isize = le32_to_cpu(ri->i_extra_isize); 118 119 if (!f2fs_sb_has_inode_chksum(sbi->sb)) 120 return false; 121 122 if (!RAW_IS_INODE(F2FS_NODE(page)) || !(ri->i_inline & F2FS_EXTRA_ATTR)) 123 return false; 124 125 if (!F2FS_FITS_IN_INODE(ri, extra_isize, i_inode_checksum)) 126 return false; 127 128 return true; 129 } 130 131 static __u32 f2fs_inode_chksum(struct f2fs_sb_info *sbi, struct page *page) 132 { 133 struct f2fs_node *node = F2FS_NODE(page); 134 struct f2fs_inode *ri = &node->i; 135 __le32 ino = node->footer.ino; 136 __le32 gen = ri->i_generation; 137 __u32 chksum, chksum_seed; 138 __u32 dummy_cs = 0; 139 unsigned int offset = offsetof(struct f2fs_inode, i_inode_checksum); 140 unsigned int cs_size = sizeof(dummy_cs); 141 142 chksum = f2fs_chksum(sbi, sbi->s_chksum_seed, (__u8 *)&ino, 143 sizeof(ino)); 144 chksum_seed = f2fs_chksum(sbi, chksum, (__u8 *)&gen, sizeof(gen)); 145 146 chksum = f2fs_chksum(sbi, chksum_seed, (__u8 *)ri, offset); 147 chksum = f2fs_chksum(sbi, chksum, (__u8 *)&dummy_cs, cs_size); 148 offset += cs_size; 149 chksum = f2fs_chksum(sbi, chksum, (__u8 *)ri + offset, 150 F2FS_BLKSIZE - offset); 151 return chksum; 152 } 153 154 bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page) 155 { 156 struct f2fs_inode *ri; 157 __u32 provided, calculated; 158 159 if (!f2fs_enable_inode_chksum(sbi, page) || 160 PageDirty(page) || PageWriteback(page)) 161 return true; 162 163 ri = &F2FS_NODE(page)->i; 164 provided = le32_to_cpu(ri->i_inode_checksum); 165 calculated = f2fs_inode_chksum(sbi, page); 166 167 if (provided != calculated) 168 f2fs_msg(sbi->sb, KERN_WARNING, 169 "checksum invalid, ino = %x, %x vs. %x", 170 ino_of_node(page), provided, calculated); 171 172 return provided == calculated; 173 } 174 175 void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page) 176 { 177 struct f2fs_inode *ri = &F2FS_NODE(page)->i; 178 179 if (!f2fs_enable_inode_chksum(sbi, page)) 180 return; 181 182 ri->i_inode_checksum = cpu_to_le32(f2fs_inode_chksum(sbi, page)); 183 } 184 185 static int do_read_inode(struct inode *inode) 186 { 187 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 188 struct f2fs_inode_info *fi = F2FS_I(inode); 189 struct page *node_page; 190 struct f2fs_inode *ri; 191 projid_t i_projid; 192 193 /* Check if ino is within scope */ 194 if (check_nid_range(sbi, inode->i_ino)) { 195 f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu", 196 (unsigned long) inode->i_ino); 197 WARN_ON(1); 198 return -EINVAL; 199 } 200 201 node_page = get_node_page(sbi, inode->i_ino); 202 if (IS_ERR(node_page)) 203 return PTR_ERR(node_page); 204 205 ri = F2FS_INODE(node_page); 206 207 inode->i_mode = le16_to_cpu(ri->i_mode); 208 i_uid_write(inode, le32_to_cpu(ri->i_uid)); 209 i_gid_write(inode, le32_to_cpu(ri->i_gid)); 210 set_nlink(inode, le32_to_cpu(ri->i_links)); 211 inode->i_size = le64_to_cpu(ri->i_size); 212 inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1); 213 214 inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime); 215 inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime); 216 inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime); 217 inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec); 218 inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec); 219 inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec); 220 inode->i_generation = le32_to_cpu(ri->i_generation); 221 222 fi->i_current_depth = le32_to_cpu(ri->i_current_depth); 223 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid); 224 fi->i_flags = le32_to_cpu(ri->i_flags); 225 fi->flags = 0; 226 fi->i_advise = ri->i_advise; 227 fi->i_pino = le32_to_cpu(ri->i_pino); 228 fi->i_dir_level = ri->i_dir_level; 229 230 if (f2fs_init_extent_tree(inode, &ri->i_ext)) 231 set_page_dirty(node_page); 232 233 get_inline_info(inode, ri); 234 235 fi->i_extra_isize = f2fs_has_extra_attr(inode) ? 236 le16_to_cpu(ri->i_extra_isize) : 0; 237 238 /* check data exist */ 239 if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode)) 240 __recover_inline_status(inode, node_page); 241 242 /* get rdev by using inline_info */ 243 __get_inode_rdev(inode, ri); 244 245 if (__written_first_block(ri)) 246 set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN); 247 248 if (!need_inode_block_update(sbi, inode->i_ino)) 249 fi->last_disk_size = inode->i_size; 250 251 if (fi->i_flags & FS_PROJINHERIT_FL) 252 set_inode_flag(inode, FI_PROJ_INHERIT); 253 254 if (f2fs_has_extra_attr(inode) && f2fs_sb_has_project_quota(sbi->sb) && 255 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) 256 i_projid = (projid_t)le32_to_cpu(ri->i_projid); 257 else 258 i_projid = F2FS_DEF_PROJID; 259 fi->i_projid = make_kprojid(&init_user_ns, i_projid); 260 261 f2fs_put_page(node_page, 1); 262 263 stat_inc_inline_xattr(inode); 264 stat_inc_inline_inode(inode); 265 stat_inc_inline_dir(inode); 266 267 return 0; 268 } 269 270 struct inode *f2fs_iget(struct super_block *sb, unsigned long ino) 271 { 272 struct f2fs_sb_info *sbi = F2FS_SB(sb); 273 struct inode *inode; 274 int ret = 0; 275 276 inode = iget_locked(sb, ino); 277 if (!inode) 278 return ERR_PTR(-ENOMEM); 279 280 if (!(inode->i_state & I_NEW)) { 281 trace_f2fs_iget(inode); 282 return inode; 283 } 284 if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi)) 285 goto make_now; 286 287 ret = do_read_inode(inode); 288 if (ret) 289 goto bad_inode; 290 make_now: 291 if (ino == F2FS_NODE_INO(sbi)) { 292 inode->i_mapping->a_ops = &f2fs_node_aops; 293 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); 294 } else if (ino == F2FS_META_INO(sbi)) { 295 inode->i_mapping->a_ops = &f2fs_meta_aops; 296 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); 297 } else if (S_ISREG(inode->i_mode)) { 298 inode->i_op = &f2fs_file_inode_operations; 299 inode->i_fop = &f2fs_file_operations; 300 inode->i_mapping->a_ops = &f2fs_dblock_aops; 301 } else if (S_ISDIR(inode->i_mode)) { 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_HIGH_ZERO); 306 } else if (S_ISLNK(inode->i_mode)) { 307 if (f2fs_encrypted_inode(inode)) 308 inode->i_op = &f2fs_encrypted_symlink_inode_operations; 309 else 310 inode->i_op = &f2fs_symlink_inode_operations; 311 inode_nohighmem(inode); 312 inode->i_mapping->a_ops = &f2fs_dblock_aops; 313 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 314 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 315 inode->i_op = &f2fs_special_inode_operations; 316 init_special_inode(inode, inode->i_mode, inode->i_rdev); 317 } else { 318 ret = -EIO; 319 goto bad_inode; 320 } 321 f2fs_set_inode_flags(inode); 322 unlock_new_inode(inode); 323 trace_f2fs_iget(inode); 324 return inode; 325 326 bad_inode: 327 iget_failed(inode); 328 trace_f2fs_iget_exit(inode, ret); 329 return ERR_PTR(ret); 330 } 331 332 struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino) 333 { 334 struct inode *inode; 335 retry: 336 inode = f2fs_iget(sb, ino); 337 if (IS_ERR(inode)) { 338 if (PTR_ERR(inode) == -ENOMEM) { 339 congestion_wait(BLK_RW_ASYNC, HZ/50); 340 goto retry; 341 } 342 } 343 return inode; 344 } 345 346 int update_inode(struct inode *inode, struct page *node_page) 347 { 348 struct f2fs_inode *ri; 349 struct extent_tree *et = F2FS_I(inode)->extent_tree; 350 351 f2fs_inode_synced(inode); 352 353 f2fs_wait_on_page_writeback(node_page, NODE, true); 354 355 ri = F2FS_INODE(node_page); 356 357 ri->i_mode = cpu_to_le16(inode->i_mode); 358 ri->i_advise = F2FS_I(inode)->i_advise; 359 ri->i_uid = cpu_to_le32(i_uid_read(inode)); 360 ri->i_gid = cpu_to_le32(i_gid_read(inode)); 361 ri->i_links = cpu_to_le32(inode->i_nlink); 362 ri->i_size = cpu_to_le64(i_size_read(inode)); 363 ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(inode->i_blocks) + 1); 364 365 if (et) { 366 read_lock(&et->lock); 367 set_raw_extent(&et->largest, &ri->i_ext); 368 read_unlock(&et->lock); 369 } else { 370 memset(&ri->i_ext, 0, sizeof(ri->i_ext)); 371 } 372 set_raw_inline(inode, ri); 373 374 ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec); 375 ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 376 ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 377 ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); 378 ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 379 ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 380 ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth); 381 ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid); 382 ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags); 383 ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino); 384 ri->i_generation = cpu_to_le32(inode->i_generation); 385 ri->i_dir_level = F2FS_I(inode)->i_dir_level; 386 387 if (f2fs_has_extra_attr(inode)) { 388 ri->i_extra_isize = cpu_to_le16(F2FS_I(inode)->i_extra_isize); 389 390 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)->sb) && 391 F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize, 392 i_projid)) { 393 projid_t i_projid; 394 395 i_projid = from_kprojid(&init_user_ns, 396 F2FS_I(inode)->i_projid); 397 ri->i_projid = cpu_to_le32(i_projid); 398 } 399 } 400 401 __set_inode_rdev(inode, ri); 402 set_cold_node(inode, node_page); 403 404 /* deleted inode */ 405 if (inode->i_nlink == 0) 406 clear_inline_node(node_page); 407 408 return set_page_dirty(node_page); 409 } 410 411 int update_inode_page(struct inode *inode) 412 { 413 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 414 struct page *node_page; 415 int ret = 0; 416 retry: 417 node_page = get_node_page(sbi, inode->i_ino); 418 if (IS_ERR(node_page)) { 419 int err = PTR_ERR(node_page); 420 if (err == -ENOMEM) { 421 cond_resched(); 422 goto retry; 423 } else if (err != -ENOENT) { 424 f2fs_stop_checkpoint(sbi, false); 425 } 426 return 0; 427 } 428 ret = update_inode(inode, node_page); 429 f2fs_put_page(node_page, 1); 430 return ret; 431 } 432 433 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc) 434 { 435 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 436 437 if (inode->i_ino == F2FS_NODE_INO(sbi) || 438 inode->i_ino == F2FS_META_INO(sbi)) 439 return 0; 440 441 if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) 442 return 0; 443 444 /* 445 * We need to balance fs here to prevent from producing dirty node pages 446 * during the urgent cleaning time when runing out of free sections. 447 */ 448 update_inode_page(inode); 449 if (wbc && wbc->nr_to_write) 450 f2fs_balance_fs(sbi, true); 451 return 0; 452 } 453 454 /* 455 * Called at the last iput() if i_nlink is zero 456 */ 457 void f2fs_evict_inode(struct inode *inode) 458 { 459 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 460 nid_t xnid = F2FS_I(inode)->i_xattr_nid; 461 int err = 0; 462 463 /* some remained atomic pages should discarded */ 464 if (f2fs_is_atomic_file(inode)) 465 drop_inmem_pages(inode); 466 467 trace_f2fs_evict_inode(inode); 468 truncate_inode_pages_final(&inode->i_data); 469 470 if (inode->i_ino == F2FS_NODE_INO(sbi) || 471 inode->i_ino == F2FS_META_INO(sbi)) 472 goto out_clear; 473 474 f2fs_bug_on(sbi, get_dirty_pages(inode)); 475 remove_dirty_inode(inode); 476 477 f2fs_destroy_extent_tree(inode); 478 479 if (inode->i_nlink || is_bad_inode(inode)) 480 goto no_delete; 481 482 dquot_initialize(inode); 483 484 remove_ino_entry(sbi, inode->i_ino, APPEND_INO); 485 remove_ino_entry(sbi, inode->i_ino, UPDATE_INO); 486 487 sb_start_intwrite(inode->i_sb); 488 set_inode_flag(inode, FI_NO_ALLOC); 489 i_size_write(inode, 0); 490 retry: 491 if (F2FS_HAS_BLOCKS(inode)) 492 err = f2fs_truncate(inode); 493 494 #ifdef CONFIG_F2FS_FAULT_INJECTION 495 if (time_to_inject(sbi, FAULT_EVICT_INODE)) { 496 f2fs_show_injection_info(FAULT_EVICT_INODE); 497 err = -EIO; 498 } 499 #endif 500 if (!err) { 501 f2fs_lock_op(sbi); 502 err = remove_inode_page(inode); 503 f2fs_unlock_op(sbi); 504 if (err == -ENOENT) 505 err = 0; 506 } 507 508 /* give more chances, if ENOMEM case */ 509 if (err == -ENOMEM) { 510 err = 0; 511 goto retry; 512 } 513 514 if (err) 515 update_inode_page(inode); 516 dquot_free_inode(inode); 517 sb_end_intwrite(inode->i_sb); 518 no_delete: 519 dquot_drop(inode); 520 521 stat_dec_inline_xattr(inode); 522 stat_dec_inline_dir(inode); 523 stat_dec_inline_inode(inode); 524 525 if (!is_set_ckpt_flags(sbi, CP_ERROR_FLAG)) 526 f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE)); 527 528 /* ino == 0, if f2fs_new_inode() was failed t*/ 529 if (inode->i_ino) 530 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, 531 inode->i_ino); 532 if (xnid) 533 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid); 534 if (inode->i_nlink) { 535 if (is_inode_flag_set(inode, FI_APPEND_WRITE)) 536 add_ino_entry(sbi, inode->i_ino, APPEND_INO); 537 if (is_inode_flag_set(inode, FI_UPDATE_WRITE)) 538 add_ino_entry(sbi, inode->i_ino, UPDATE_INO); 539 } 540 if (is_inode_flag_set(inode, FI_FREE_NID)) { 541 alloc_nid_failed(sbi, inode->i_ino); 542 clear_inode_flag(inode, FI_FREE_NID); 543 } else { 544 f2fs_bug_on(sbi, err && 545 !exist_written_data(sbi, inode->i_ino, ORPHAN_INO)); 546 } 547 out_clear: 548 fscrypt_put_encryption_info(inode, NULL); 549 clear_inode(inode); 550 } 551 552 /* caller should call f2fs_lock_op() */ 553 void handle_failed_inode(struct inode *inode) 554 { 555 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 556 struct node_info ni; 557 558 /* 559 * clear nlink of inode in order to release resource of inode 560 * immediately. 561 */ 562 clear_nlink(inode); 563 564 /* 565 * we must call this to avoid inode being remained as dirty, resulting 566 * in a panic when flushing dirty inodes in gdirty_list. 567 */ 568 update_inode_page(inode); 569 f2fs_inode_synced(inode); 570 571 /* don't make bad inode, since it becomes a regular file. */ 572 unlock_new_inode(inode); 573 574 /* 575 * Note: we should add inode to orphan list before f2fs_unlock_op() 576 * so we can prevent losing this orphan when encoutering checkpoint 577 * and following suddenly power-off. 578 */ 579 get_node_info(sbi, inode->i_ino, &ni); 580 581 if (ni.blk_addr != NULL_ADDR) { 582 int err = acquire_orphan_inode(sbi); 583 if (err) { 584 set_sbi_flag(sbi, SBI_NEED_FSCK); 585 f2fs_msg(sbi->sb, KERN_WARNING, 586 "Too many orphan inodes, run fsck to fix."); 587 } else { 588 add_orphan_inode(inode); 589 } 590 alloc_nid_done(sbi, inode->i_ino); 591 } else { 592 set_inode_flag(inode, FI_FREE_NID); 593 } 594 595 f2fs_unlock_op(sbi); 596 597 /* iput will drop the inode object */ 598 iput(inode); 599 } 600