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