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