1 /* 2 * fs/f2fs/inline.c 3 * Copyright (c) 2013, Intel Corporation 4 * Authors: Huajun Li <huajun.li@intel.com> 5 * Haicheng Li <haicheng.li@intel.com> 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/fs.h> 12 #include <linux/f2fs_fs.h> 13 14 #include "f2fs.h" 15 #include "node.h" 16 17 bool f2fs_may_inline_data(struct inode *inode) 18 { 19 if (f2fs_is_atomic_file(inode)) 20 return false; 21 22 if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) 23 return false; 24 25 if (i_size_read(inode) > MAX_INLINE_DATA) 26 return false; 27 28 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 29 return false; 30 31 return true; 32 } 33 34 bool f2fs_may_inline_dentry(struct inode *inode) 35 { 36 if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY)) 37 return false; 38 39 if (!S_ISDIR(inode->i_mode)) 40 return false; 41 42 return true; 43 } 44 45 void read_inline_data(struct page *page, struct page *ipage) 46 { 47 void *src_addr, *dst_addr; 48 49 if (PageUptodate(page)) 50 return; 51 52 f2fs_bug_on(F2FS_P_SB(page), page->index); 53 54 zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE); 55 56 /* Copy the whole inline data block */ 57 src_addr = inline_data_addr(ipage); 58 dst_addr = kmap_atomic(page); 59 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 60 flush_dcache_page(page); 61 kunmap_atomic(dst_addr); 62 if (!PageUptodate(page)) 63 SetPageUptodate(page); 64 } 65 66 void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from) 67 { 68 void *addr; 69 70 if (from >= MAX_INLINE_DATA) 71 return; 72 73 addr = inline_data_addr(ipage); 74 75 f2fs_wait_on_page_writeback(ipage, NODE, true); 76 memset(addr + from, 0, MAX_INLINE_DATA - from); 77 set_page_dirty(ipage); 78 79 if (from == 0) 80 clear_inode_flag(inode, FI_DATA_EXIST); 81 } 82 83 int f2fs_read_inline_data(struct inode *inode, struct page *page) 84 { 85 struct page *ipage; 86 87 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 88 if (IS_ERR(ipage)) { 89 unlock_page(page); 90 return PTR_ERR(ipage); 91 } 92 93 if (!f2fs_has_inline_data(inode)) { 94 f2fs_put_page(ipage, 1); 95 return -EAGAIN; 96 } 97 98 if (page->index) 99 zero_user_segment(page, 0, PAGE_SIZE); 100 else 101 read_inline_data(page, ipage); 102 103 if (!PageUptodate(page)) 104 SetPageUptodate(page); 105 f2fs_put_page(ipage, 1); 106 unlock_page(page); 107 return 0; 108 } 109 110 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) 111 { 112 struct f2fs_io_info fio = { 113 .sbi = F2FS_I_SB(dn->inode), 114 .type = DATA, 115 .op = REQ_OP_WRITE, 116 .op_flags = REQ_SYNC | REQ_PRIO, 117 .page = page, 118 .encrypted_page = NULL, 119 }; 120 int dirty, err; 121 122 if (!f2fs_exist_data(dn->inode)) 123 goto clear_out; 124 125 err = f2fs_reserve_block(dn, 0); 126 if (err) 127 return err; 128 129 f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page)); 130 131 read_inline_data(page, dn->inode_page); 132 set_page_dirty(page); 133 134 /* clear dirty state */ 135 dirty = clear_page_dirty_for_io(page); 136 137 /* write data page to try to make data consistent */ 138 set_page_writeback(page); 139 fio.old_blkaddr = dn->data_blkaddr; 140 set_inode_flag(dn->inode, FI_HOT_DATA); 141 write_data_page(dn, &fio); 142 f2fs_wait_on_page_writeback(page, DATA, true); 143 if (dirty) { 144 inode_dec_dirty_pages(dn->inode); 145 remove_dirty_inode(dn->inode); 146 } 147 148 /* this converted inline_data should be recovered. */ 149 set_inode_flag(dn->inode, FI_APPEND_WRITE); 150 151 /* clear inline data and flag after data writeback */ 152 truncate_inline_inode(dn->inode, dn->inode_page, 0); 153 clear_inline_node(dn->inode_page); 154 clear_out: 155 stat_dec_inline_inode(dn->inode); 156 clear_inode_flag(dn->inode, FI_INLINE_DATA); 157 f2fs_put_dnode(dn); 158 return 0; 159 } 160 161 int f2fs_convert_inline_inode(struct inode *inode) 162 { 163 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 164 struct dnode_of_data dn; 165 struct page *ipage, *page; 166 int err = 0; 167 168 if (!f2fs_has_inline_data(inode)) 169 return 0; 170 171 page = f2fs_grab_cache_page(inode->i_mapping, 0, false); 172 if (!page) 173 return -ENOMEM; 174 175 f2fs_lock_op(sbi); 176 177 ipage = get_node_page(sbi, inode->i_ino); 178 if (IS_ERR(ipage)) { 179 err = PTR_ERR(ipage); 180 goto out; 181 } 182 183 set_new_dnode(&dn, inode, ipage, ipage, 0); 184 185 if (f2fs_has_inline_data(inode)) 186 err = f2fs_convert_inline_page(&dn, page); 187 188 f2fs_put_dnode(&dn); 189 out: 190 f2fs_unlock_op(sbi); 191 192 f2fs_put_page(page, 1); 193 194 f2fs_balance_fs(sbi, dn.node_changed); 195 196 return err; 197 } 198 199 int f2fs_write_inline_data(struct inode *inode, struct page *page) 200 { 201 void *src_addr, *dst_addr; 202 struct dnode_of_data dn; 203 int err; 204 205 set_new_dnode(&dn, inode, NULL, NULL, 0); 206 err = get_dnode_of_data(&dn, 0, LOOKUP_NODE); 207 if (err) 208 return err; 209 210 if (!f2fs_has_inline_data(inode)) { 211 f2fs_put_dnode(&dn); 212 return -EAGAIN; 213 } 214 215 f2fs_bug_on(F2FS_I_SB(inode), page->index); 216 217 f2fs_wait_on_page_writeback(dn.inode_page, NODE, true); 218 src_addr = kmap_atomic(page); 219 dst_addr = inline_data_addr(dn.inode_page); 220 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 221 kunmap_atomic(src_addr); 222 set_page_dirty(dn.inode_page); 223 224 set_inode_flag(inode, FI_APPEND_WRITE); 225 set_inode_flag(inode, FI_DATA_EXIST); 226 227 clear_inline_node(dn.inode_page); 228 f2fs_put_dnode(&dn); 229 return 0; 230 } 231 232 bool recover_inline_data(struct inode *inode, struct page *npage) 233 { 234 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 235 struct f2fs_inode *ri = NULL; 236 void *src_addr, *dst_addr; 237 struct page *ipage; 238 239 /* 240 * The inline_data recovery policy is as follows. 241 * [prev.] [next] of inline_data flag 242 * o o -> recover inline_data 243 * o x -> remove inline_data, and then recover data blocks 244 * x o -> remove inline_data, and then recover inline_data 245 * x x -> recover data blocks 246 */ 247 if (IS_INODE(npage)) 248 ri = F2FS_INODE(npage); 249 250 if (f2fs_has_inline_data(inode) && 251 ri && (ri->i_inline & F2FS_INLINE_DATA)) { 252 process_inline: 253 ipage = get_node_page(sbi, inode->i_ino); 254 f2fs_bug_on(sbi, IS_ERR(ipage)); 255 256 f2fs_wait_on_page_writeback(ipage, NODE, true); 257 258 src_addr = inline_data_addr(npage); 259 dst_addr = inline_data_addr(ipage); 260 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 261 262 set_inode_flag(inode, FI_INLINE_DATA); 263 set_inode_flag(inode, FI_DATA_EXIST); 264 265 set_page_dirty(ipage); 266 f2fs_put_page(ipage, 1); 267 return true; 268 } 269 270 if (f2fs_has_inline_data(inode)) { 271 ipage = get_node_page(sbi, inode->i_ino); 272 f2fs_bug_on(sbi, IS_ERR(ipage)); 273 truncate_inline_inode(inode, ipage, 0); 274 clear_inode_flag(inode, FI_INLINE_DATA); 275 f2fs_put_page(ipage, 1); 276 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 277 if (truncate_blocks(inode, 0, false)) 278 return false; 279 goto process_inline; 280 } 281 return false; 282 } 283 284 struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, 285 struct fscrypt_name *fname, struct page **res_page) 286 { 287 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 288 struct f2fs_inline_dentry *inline_dentry; 289 struct qstr name = FSTR_TO_QSTR(&fname->disk_name); 290 struct f2fs_dir_entry *de; 291 struct f2fs_dentry_ptr d; 292 struct page *ipage; 293 f2fs_hash_t namehash; 294 295 ipage = get_node_page(sbi, dir->i_ino); 296 if (IS_ERR(ipage)) { 297 *res_page = ipage; 298 return NULL; 299 } 300 301 namehash = f2fs_dentry_hash(&name, fname); 302 303 inline_dentry = inline_data_addr(ipage); 304 305 make_dentry_ptr_inline(NULL, &d, inline_dentry); 306 de = find_target_dentry(fname, namehash, NULL, &d); 307 unlock_page(ipage); 308 if (de) 309 *res_page = ipage; 310 else 311 f2fs_put_page(ipage, 0); 312 313 return de; 314 } 315 316 int make_empty_inline_dir(struct inode *inode, struct inode *parent, 317 struct page *ipage) 318 { 319 struct f2fs_inline_dentry *inline_dentry; 320 struct f2fs_dentry_ptr d; 321 322 inline_dentry = inline_data_addr(ipage); 323 324 make_dentry_ptr_inline(NULL, &d, inline_dentry); 325 do_make_empty_dir(inode, parent, &d); 326 327 set_page_dirty(ipage); 328 329 /* update i_size to MAX_INLINE_DATA */ 330 if (i_size_read(inode) < MAX_INLINE_DATA) 331 f2fs_i_size_write(inode, MAX_INLINE_DATA); 332 return 0; 333 } 334 335 /* 336 * NOTE: ipage is grabbed by caller, but if any error occurs, we should 337 * release ipage in this function. 338 */ 339 static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, 340 struct f2fs_inline_dentry *inline_dentry) 341 { 342 struct page *page; 343 struct dnode_of_data dn; 344 struct f2fs_dentry_block *dentry_blk; 345 int err; 346 347 page = f2fs_grab_cache_page(dir->i_mapping, 0, false); 348 if (!page) { 349 f2fs_put_page(ipage, 1); 350 return -ENOMEM; 351 } 352 353 set_new_dnode(&dn, dir, ipage, NULL, 0); 354 err = f2fs_reserve_block(&dn, 0); 355 if (err) 356 goto out; 357 358 f2fs_wait_on_page_writeback(page, DATA, true); 359 zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE); 360 361 dentry_blk = kmap_atomic(page); 362 363 /* copy data from inline dentry block to new dentry block */ 364 memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap, 365 INLINE_DENTRY_BITMAP_SIZE); 366 memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0, 367 SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE); 368 /* 369 * we do not need to zero out remainder part of dentry and filename 370 * field, since we have used bitmap for marking the usage status of 371 * them, besides, we can also ignore copying/zeroing reserved space 372 * of dentry block, because them haven't been used so far. 373 */ 374 memcpy(dentry_blk->dentry, inline_dentry->dentry, 375 sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY); 376 memcpy(dentry_blk->filename, inline_dentry->filename, 377 NR_INLINE_DENTRY * F2FS_SLOT_LEN); 378 379 kunmap_atomic(dentry_blk); 380 if (!PageUptodate(page)) 381 SetPageUptodate(page); 382 set_page_dirty(page); 383 384 /* clear inline dir and flag after data writeback */ 385 truncate_inline_inode(dir, ipage, 0); 386 387 stat_dec_inline_dir(dir); 388 clear_inode_flag(dir, FI_INLINE_DENTRY); 389 390 f2fs_i_depth_write(dir, 1); 391 if (i_size_read(dir) < PAGE_SIZE) 392 f2fs_i_size_write(dir, PAGE_SIZE); 393 out: 394 f2fs_put_page(page, 1); 395 return err; 396 } 397 398 static int f2fs_add_inline_entries(struct inode *dir, 399 struct f2fs_inline_dentry *inline_dentry) 400 { 401 struct f2fs_dentry_ptr d; 402 unsigned long bit_pos = 0; 403 int err = 0; 404 405 make_dentry_ptr_inline(NULL, &d, inline_dentry); 406 407 while (bit_pos < d.max) { 408 struct f2fs_dir_entry *de; 409 struct qstr new_name; 410 nid_t ino; 411 umode_t fake_mode; 412 413 if (!test_bit_le(bit_pos, d.bitmap)) { 414 bit_pos++; 415 continue; 416 } 417 418 de = &d.dentry[bit_pos]; 419 420 if (unlikely(!de->name_len)) { 421 bit_pos++; 422 continue; 423 } 424 425 new_name.name = d.filename[bit_pos]; 426 new_name.len = le16_to_cpu(de->name_len); 427 428 ino = le32_to_cpu(de->ino); 429 fake_mode = get_de_type(de) << S_SHIFT; 430 431 err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL, 432 ino, fake_mode); 433 if (err) 434 goto punch_dentry_pages; 435 436 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 437 } 438 return 0; 439 punch_dentry_pages: 440 truncate_inode_pages(&dir->i_data, 0); 441 truncate_blocks(dir, 0, false); 442 remove_dirty_inode(dir); 443 return err; 444 } 445 446 static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, 447 struct f2fs_inline_dentry *inline_dentry) 448 { 449 struct f2fs_inline_dentry *backup_dentry; 450 int err; 451 452 backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), 453 sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO); 454 if (!backup_dentry) { 455 f2fs_put_page(ipage, 1); 456 return -ENOMEM; 457 } 458 459 memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA); 460 truncate_inline_inode(dir, ipage, 0); 461 462 unlock_page(ipage); 463 464 err = f2fs_add_inline_entries(dir, backup_dentry); 465 if (err) 466 goto recover; 467 468 lock_page(ipage); 469 470 stat_dec_inline_dir(dir); 471 clear_inode_flag(dir, FI_INLINE_DENTRY); 472 kfree(backup_dentry); 473 return 0; 474 recover: 475 lock_page(ipage); 476 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA); 477 f2fs_i_depth_write(dir, 0); 478 f2fs_i_size_write(dir, MAX_INLINE_DATA); 479 set_page_dirty(ipage); 480 f2fs_put_page(ipage, 1); 481 482 kfree(backup_dentry); 483 return err; 484 } 485 486 static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, 487 struct f2fs_inline_dentry *inline_dentry) 488 { 489 if (!F2FS_I(dir)->i_dir_level) 490 return f2fs_move_inline_dirents(dir, ipage, inline_dentry); 491 else 492 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); 493 } 494 495 int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, 496 const struct qstr *orig_name, 497 struct inode *inode, nid_t ino, umode_t mode) 498 { 499 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 500 struct page *ipage; 501 unsigned int bit_pos; 502 f2fs_hash_t name_hash; 503 struct f2fs_inline_dentry *inline_dentry = NULL; 504 struct f2fs_dentry_ptr d; 505 int slots = GET_DENTRY_SLOTS(new_name->len); 506 struct page *page = NULL; 507 int err = 0; 508 509 ipage = get_node_page(sbi, dir->i_ino); 510 if (IS_ERR(ipage)) 511 return PTR_ERR(ipage); 512 513 inline_dentry = inline_data_addr(ipage); 514 bit_pos = room_for_filename(&inline_dentry->dentry_bitmap, 515 slots, NR_INLINE_DENTRY); 516 if (bit_pos >= NR_INLINE_DENTRY) { 517 err = f2fs_convert_inline_dir(dir, ipage, inline_dentry); 518 if (err) 519 return err; 520 err = -EAGAIN; 521 goto out; 522 } 523 524 if (inode) { 525 down_write(&F2FS_I(inode)->i_sem); 526 page = init_inode_metadata(inode, dir, new_name, 527 orig_name, ipage); 528 if (IS_ERR(page)) { 529 err = PTR_ERR(page); 530 goto fail; 531 } 532 } 533 534 f2fs_wait_on_page_writeback(ipage, NODE, true); 535 536 name_hash = f2fs_dentry_hash(new_name, NULL); 537 make_dentry_ptr_inline(NULL, &d, inline_dentry); 538 f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos); 539 540 set_page_dirty(ipage); 541 542 /* we don't need to mark_inode_dirty now */ 543 if (inode) { 544 f2fs_i_pino_write(inode, dir->i_ino); 545 f2fs_put_page(page, 1); 546 } 547 548 update_parent_metadata(dir, inode, 0); 549 fail: 550 if (inode) 551 up_write(&F2FS_I(inode)->i_sem); 552 out: 553 f2fs_put_page(ipage, 1); 554 return err; 555 } 556 557 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, 558 struct inode *dir, struct inode *inode) 559 { 560 struct f2fs_inline_dentry *inline_dentry; 561 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 562 unsigned int bit_pos; 563 int i; 564 565 lock_page(page); 566 f2fs_wait_on_page_writeback(page, NODE, true); 567 568 inline_dentry = inline_data_addr(page); 569 bit_pos = dentry - inline_dentry->dentry; 570 for (i = 0; i < slots; i++) 571 __clear_bit_le(bit_pos + i, 572 &inline_dentry->dentry_bitmap); 573 574 set_page_dirty(page); 575 f2fs_put_page(page, 1); 576 577 dir->i_ctime = dir->i_mtime = current_time(dir); 578 f2fs_mark_inode_dirty_sync(dir, false); 579 580 if (inode) 581 f2fs_drop_nlink(dir, inode); 582 } 583 584 bool f2fs_empty_inline_dir(struct inode *dir) 585 { 586 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 587 struct page *ipage; 588 unsigned int bit_pos = 2; 589 struct f2fs_inline_dentry *inline_dentry; 590 591 ipage = get_node_page(sbi, dir->i_ino); 592 if (IS_ERR(ipage)) 593 return false; 594 595 inline_dentry = inline_data_addr(ipage); 596 bit_pos = find_next_bit_le(&inline_dentry->dentry_bitmap, 597 NR_INLINE_DENTRY, 598 bit_pos); 599 600 f2fs_put_page(ipage, 1); 601 602 if (bit_pos < NR_INLINE_DENTRY) 603 return false; 604 605 return true; 606 } 607 608 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 609 struct fscrypt_str *fstr) 610 { 611 struct inode *inode = file_inode(file); 612 struct f2fs_inline_dentry *inline_dentry = NULL; 613 struct page *ipage = NULL; 614 struct f2fs_dentry_ptr d; 615 int err; 616 617 if (ctx->pos == NR_INLINE_DENTRY) 618 return 0; 619 620 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 621 if (IS_ERR(ipage)) 622 return PTR_ERR(ipage); 623 624 inline_dentry = inline_data_addr(ipage); 625 626 make_dentry_ptr_inline(inode, &d, inline_dentry); 627 628 err = f2fs_fill_dentries(ctx, &d, 0, fstr); 629 if (!err) 630 ctx->pos = NR_INLINE_DENTRY; 631 632 f2fs_put_page(ipage, 1); 633 return err < 0 ? err : 0; 634 } 635 636 int f2fs_inline_data_fiemap(struct inode *inode, 637 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) 638 { 639 __u64 byteaddr, ilen; 640 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | 641 FIEMAP_EXTENT_LAST; 642 struct node_info ni; 643 struct page *ipage; 644 int err = 0; 645 646 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 647 if (IS_ERR(ipage)) 648 return PTR_ERR(ipage); 649 650 if (!f2fs_has_inline_data(inode)) { 651 err = -EAGAIN; 652 goto out; 653 } 654 655 ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode)); 656 if (start >= ilen) 657 goto out; 658 if (start + len < ilen) 659 ilen = start + len; 660 ilen -= start; 661 662 get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni); 663 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; 664 byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage); 665 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); 666 out: 667 f2fs_put_page(ipage, 1); 668 return err; 669 } 670