1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * Copyright (c) 2012 Taobao. 4 * Written by Tao Ma <boyu.mt@taobao.com> 5 */ 6 7 #include <linux/iomap.h> 8 #include <linux/fiemap.h> 9 #include <linux/namei.h> 10 #include <linux/iversion.h> 11 #include <linux/sched/mm.h> 12 13 #include "ext4_jbd2.h" 14 #include "ext4.h" 15 #include "xattr.h" 16 #include "truncate.h" 17 18 #define EXT4_XATTR_SYSTEM_DATA "data" 19 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS)) 20 #define EXT4_INLINE_DOTDOT_OFFSET 2 21 #define EXT4_INLINE_DOTDOT_SIZE 4 22 23 static int ext4_get_inline_size(struct inode *inode) 24 { 25 if (EXT4_I(inode)->i_inline_off) 26 return EXT4_I(inode)->i_inline_size; 27 28 return 0; 29 } 30 31 static int get_max_inline_xattr_value_size(struct inode *inode, 32 struct ext4_iloc *iloc) 33 { 34 struct ext4_xattr_ibody_header *header; 35 struct ext4_xattr_entry *entry; 36 struct ext4_inode *raw_inode; 37 int free, min_offs; 38 39 if (!EXT4_INODE_HAS_XATTR_SPACE(inode)) 40 return 0; 41 42 min_offs = EXT4_SB(inode->i_sb)->s_inode_size - 43 EXT4_GOOD_OLD_INODE_SIZE - 44 EXT4_I(inode)->i_extra_isize - 45 sizeof(struct ext4_xattr_ibody_header); 46 47 /* 48 * We need to subtract another sizeof(__u32) since an in-inode xattr 49 * needs an empty 4 bytes to indicate the gap between the xattr entry 50 * and the name/value pair. 51 */ 52 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR)) 53 return EXT4_XATTR_SIZE(min_offs - 54 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA)) - 55 EXT4_XATTR_ROUND - sizeof(__u32)); 56 57 raw_inode = ext4_raw_inode(iloc); 58 header = IHDR(inode, raw_inode); 59 entry = IFIRST(header); 60 61 /* Compute min_offs. */ 62 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) { 63 if (!entry->e_value_inum && entry->e_value_size) { 64 size_t offs = le16_to_cpu(entry->e_value_offs); 65 if (offs < min_offs) 66 min_offs = offs; 67 } 68 } 69 free = min_offs - 70 ((void *)entry - (void *)IFIRST(header)) - sizeof(__u32); 71 72 if (EXT4_I(inode)->i_inline_off) { 73 entry = (struct ext4_xattr_entry *) 74 ((void *)raw_inode + EXT4_I(inode)->i_inline_off); 75 76 free += EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size)); 77 goto out; 78 } 79 80 free -= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA)); 81 82 if (free > EXT4_XATTR_ROUND) 83 free = EXT4_XATTR_SIZE(free - EXT4_XATTR_ROUND); 84 else 85 free = 0; 86 87 out: 88 return free; 89 } 90 91 /* 92 * Get the maximum size we now can store in an inode. 93 * If we can't find the space for a xattr entry, don't use the space 94 * of the extents since we have no space to indicate the inline data. 95 */ 96 int ext4_get_max_inline_size(struct inode *inode) 97 { 98 int error, max_inline_size; 99 struct ext4_iloc iloc; 100 101 if (EXT4_I(inode)->i_extra_isize == 0) 102 return 0; 103 104 error = ext4_get_inode_loc(inode, &iloc); 105 if (error) { 106 ext4_error_inode_err(inode, __func__, __LINE__, 0, -error, 107 "can't get inode location %lu", 108 inode->i_ino); 109 return 0; 110 } 111 112 down_read(&EXT4_I(inode)->xattr_sem); 113 max_inline_size = get_max_inline_xattr_value_size(inode, &iloc); 114 up_read(&EXT4_I(inode)->xattr_sem); 115 116 brelse(iloc.bh); 117 118 if (!max_inline_size) 119 return 0; 120 121 return max_inline_size + EXT4_MIN_INLINE_DATA_SIZE; 122 } 123 124 /* 125 * this function does not take xattr_sem, which is OK because it is 126 * currently only used in a code path coming form ext4_iget, before 127 * the new inode has been unlocked 128 */ 129 int ext4_find_inline_data_nolock(struct inode *inode) 130 { 131 struct ext4_xattr_ibody_find is = { 132 .s = { .not_found = -ENODATA, }, 133 }; 134 struct ext4_xattr_info i = { 135 .name_index = EXT4_XATTR_INDEX_SYSTEM, 136 .name = EXT4_XATTR_SYSTEM_DATA, 137 }; 138 int error; 139 140 if (EXT4_I(inode)->i_extra_isize == 0) 141 return 0; 142 143 error = ext4_get_inode_loc(inode, &is.iloc); 144 if (error) 145 return error; 146 147 error = ext4_xattr_ibody_find(inode, &i, &is); 148 if (error) 149 goto out; 150 151 if (!is.s.not_found) { 152 if (is.s.here->e_value_inum) { 153 EXT4_ERROR_INODE(inode, "inline data xattr refers " 154 "to an external xattr inode"); 155 error = -EFSCORRUPTED; 156 goto out; 157 } 158 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here - 159 (void *)ext4_raw_inode(&is.iloc)); 160 EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE + 161 le32_to_cpu(is.s.here->e_value_size); 162 } 163 out: 164 brelse(is.iloc.bh); 165 return error; 166 } 167 168 static int ext4_read_inline_data(struct inode *inode, void *buffer, 169 unsigned int len, 170 struct ext4_iloc *iloc) 171 { 172 struct ext4_xattr_entry *entry; 173 struct ext4_xattr_ibody_header *header; 174 int cp_len = 0; 175 struct ext4_inode *raw_inode; 176 177 if (!len) 178 return 0; 179 180 BUG_ON(len > EXT4_I(inode)->i_inline_size); 181 182 cp_len = min_t(unsigned int, len, EXT4_MIN_INLINE_DATA_SIZE); 183 184 raw_inode = ext4_raw_inode(iloc); 185 memcpy(buffer, (void *)(raw_inode->i_block), cp_len); 186 187 len -= cp_len; 188 buffer += cp_len; 189 190 if (!len) 191 goto out; 192 193 header = IHDR(inode, raw_inode); 194 entry = (struct ext4_xattr_entry *)((void *)raw_inode + 195 EXT4_I(inode)->i_inline_off); 196 len = min_t(unsigned int, len, 197 (unsigned int)le32_to_cpu(entry->e_value_size)); 198 199 memcpy(buffer, 200 (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs), len); 201 cp_len += len; 202 203 out: 204 return cp_len; 205 } 206 207 /* 208 * write the buffer to the inline inode. 209 * If 'create' is set, we don't need to do the extra copy in the xattr 210 * value since it is already handled by ext4_xattr_ibody_set. 211 * That saves us one memcpy. 212 */ 213 static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc, 214 void *buffer, loff_t pos, unsigned int len) 215 { 216 struct ext4_xattr_entry *entry; 217 struct ext4_xattr_ibody_header *header; 218 struct ext4_inode *raw_inode; 219 int cp_len = 0; 220 221 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) 222 return; 223 224 BUG_ON(!EXT4_I(inode)->i_inline_off); 225 BUG_ON(pos + len > EXT4_I(inode)->i_inline_size); 226 227 raw_inode = ext4_raw_inode(iloc); 228 buffer += pos; 229 230 if (pos < EXT4_MIN_INLINE_DATA_SIZE) { 231 cp_len = pos + len > EXT4_MIN_INLINE_DATA_SIZE ? 232 EXT4_MIN_INLINE_DATA_SIZE - pos : len; 233 memcpy((void *)raw_inode->i_block + pos, buffer, cp_len); 234 235 len -= cp_len; 236 buffer += cp_len; 237 pos += cp_len; 238 } 239 240 if (!len) 241 return; 242 243 pos -= EXT4_MIN_INLINE_DATA_SIZE; 244 header = IHDR(inode, raw_inode); 245 entry = (struct ext4_xattr_entry *)((void *)raw_inode + 246 EXT4_I(inode)->i_inline_off); 247 248 memcpy((void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs) + pos, 249 buffer, len); 250 } 251 252 static int ext4_create_inline_data(handle_t *handle, 253 struct inode *inode, unsigned len) 254 { 255 int error; 256 void *value = NULL; 257 struct ext4_xattr_ibody_find is = { 258 .s = { .not_found = -ENODATA, }, 259 }; 260 struct ext4_xattr_info i = { 261 .name_index = EXT4_XATTR_INDEX_SYSTEM, 262 .name = EXT4_XATTR_SYSTEM_DATA, 263 }; 264 265 error = ext4_get_inode_loc(inode, &is.iloc); 266 if (error) 267 return error; 268 269 BUFFER_TRACE(is.iloc.bh, "get_write_access"); 270 error = ext4_journal_get_write_access(handle, inode->i_sb, is.iloc.bh, 271 EXT4_JTR_NONE); 272 if (error) 273 goto out; 274 275 if (len > EXT4_MIN_INLINE_DATA_SIZE) { 276 value = EXT4_ZERO_XATTR_VALUE; 277 len -= EXT4_MIN_INLINE_DATA_SIZE; 278 } else { 279 value = ""; 280 len = 0; 281 } 282 283 /* Insert the xttr entry. */ 284 i.value = value; 285 i.value_len = len; 286 287 error = ext4_xattr_ibody_find(inode, &i, &is); 288 if (error) 289 goto out; 290 291 BUG_ON(!is.s.not_found); 292 293 error = ext4_xattr_ibody_set(handle, inode, &i, &is); 294 if (error) { 295 if (error == -ENOSPC) 296 ext4_clear_inode_state(inode, 297 EXT4_STATE_MAY_INLINE_DATA); 298 goto out; 299 } 300 301 memset((void *)ext4_raw_inode(&is.iloc)->i_block, 302 0, EXT4_MIN_INLINE_DATA_SIZE); 303 304 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here - 305 (void *)ext4_raw_inode(&is.iloc)); 306 EXT4_I(inode)->i_inline_size = len + EXT4_MIN_INLINE_DATA_SIZE; 307 ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS); 308 ext4_set_inode_flag(inode, EXT4_INODE_INLINE_DATA); 309 get_bh(is.iloc.bh); 310 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); 311 312 out: 313 brelse(is.iloc.bh); 314 return error; 315 } 316 317 static int ext4_update_inline_data(handle_t *handle, struct inode *inode, 318 unsigned int len) 319 { 320 int error; 321 void *value = NULL; 322 struct ext4_xattr_ibody_find is = { 323 .s = { .not_found = -ENODATA, }, 324 }; 325 struct ext4_xattr_info i = { 326 .name_index = EXT4_XATTR_INDEX_SYSTEM, 327 .name = EXT4_XATTR_SYSTEM_DATA, 328 }; 329 330 /* If the old space is ok, write the data directly. */ 331 if (len <= EXT4_I(inode)->i_inline_size) 332 return 0; 333 334 error = ext4_get_inode_loc(inode, &is.iloc); 335 if (error) 336 return error; 337 338 error = ext4_xattr_ibody_find(inode, &i, &is); 339 if (error) 340 goto out; 341 342 BUG_ON(is.s.not_found); 343 344 len -= EXT4_MIN_INLINE_DATA_SIZE; 345 value = kzalloc(len, GFP_NOFS); 346 if (!value) { 347 error = -ENOMEM; 348 goto out; 349 } 350 351 error = ext4_xattr_ibody_get(inode, i.name_index, i.name, 352 value, len); 353 if (error == -ENODATA) 354 goto out; 355 356 BUFFER_TRACE(is.iloc.bh, "get_write_access"); 357 error = ext4_journal_get_write_access(handle, inode->i_sb, is.iloc.bh, 358 EXT4_JTR_NONE); 359 if (error) 360 goto out; 361 362 /* Update the xattr entry. */ 363 i.value = value; 364 i.value_len = len; 365 366 error = ext4_xattr_ibody_set(handle, inode, &i, &is); 367 if (error) 368 goto out; 369 370 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here - 371 (void *)ext4_raw_inode(&is.iloc)); 372 EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE + 373 le32_to_cpu(is.s.here->e_value_size); 374 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 375 get_bh(is.iloc.bh); 376 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); 377 378 out: 379 kfree(value); 380 brelse(is.iloc.bh); 381 return error; 382 } 383 384 static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode, 385 unsigned int len) 386 { 387 int ret, size, no_expand; 388 struct ext4_inode_info *ei = EXT4_I(inode); 389 390 if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) 391 return -ENOSPC; 392 393 size = ext4_get_max_inline_size(inode); 394 if (size < len) 395 return -ENOSPC; 396 397 ext4_write_lock_xattr(inode, &no_expand); 398 399 if (ei->i_inline_off) 400 ret = ext4_update_inline_data(handle, inode, len); 401 else 402 ret = ext4_create_inline_data(handle, inode, len); 403 404 ext4_write_unlock_xattr(inode, &no_expand); 405 return ret; 406 } 407 408 static int ext4_destroy_inline_data_nolock(handle_t *handle, 409 struct inode *inode) 410 { 411 struct ext4_inode_info *ei = EXT4_I(inode); 412 struct ext4_xattr_ibody_find is = { 413 .s = { .not_found = 0, }, 414 }; 415 struct ext4_xattr_info i = { 416 .name_index = EXT4_XATTR_INDEX_SYSTEM, 417 .name = EXT4_XATTR_SYSTEM_DATA, 418 .value = NULL, 419 .value_len = 0, 420 }; 421 int error; 422 423 if (!ei->i_inline_off) 424 return 0; 425 426 error = ext4_get_inode_loc(inode, &is.iloc); 427 if (error) 428 return error; 429 430 error = ext4_xattr_ibody_find(inode, &i, &is); 431 if (error) 432 goto out; 433 434 BUFFER_TRACE(is.iloc.bh, "get_write_access"); 435 error = ext4_journal_get_write_access(handle, inode->i_sb, is.iloc.bh, 436 EXT4_JTR_NONE); 437 if (error) 438 goto out; 439 440 error = ext4_xattr_ibody_set(handle, inode, &i, &is); 441 if (error) 442 goto out; 443 444 memset((void *)ext4_raw_inode(&is.iloc)->i_block, 445 0, EXT4_MIN_INLINE_DATA_SIZE); 446 memset(ei->i_data, 0, EXT4_MIN_INLINE_DATA_SIZE); 447 448 if (ext4_has_feature_extents(inode->i_sb)) { 449 if (S_ISDIR(inode->i_mode) || 450 S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) { 451 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS); 452 ext4_ext_tree_init(handle, inode); 453 } 454 } 455 ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA); 456 457 get_bh(is.iloc.bh); 458 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); 459 460 EXT4_I(inode)->i_inline_off = 0; 461 EXT4_I(inode)->i_inline_size = 0; 462 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 463 out: 464 brelse(is.iloc.bh); 465 if (error == -ENODATA) 466 error = 0; 467 return error; 468 } 469 470 static int ext4_read_inline_folio(struct inode *inode, struct folio *folio) 471 { 472 void *kaddr; 473 int ret = 0; 474 size_t len; 475 struct ext4_iloc iloc; 476 477 BUG_ON(!folio_test_locked(folio)); 478 BUG_ON(!ext4_has_inline_data(inode)); 479 BUG_ON(folio->index); 480 481 if (!EXT4_I(inode)->i_inline_off) { 482 ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.", 483 inode->i_ino); 484 goto out; 485 } 486 487 ret = ext4_get_inode_loc(inode, &iloc); 488 if (ret) 489 goto out; 490 491 len = min_t(size_t, ext4_get_inline_size(inode), i_size_read(inode)); 492 BUG_ON(len > PAGE_SIZE); 493 kaddr = kmap_local_folio(folio, 0); 494 ret = ext4_read_inline_data(inode, kaddr, len, &iloc); 495 flush_dcache_folio(folio); 496 kunmap_local(kaddr); 497 folio_zero_segment(folio, len, folio_size(folio)); 498 folio_mark_uptodate(folio); 499 brelse(iloc.bh); 500 501 out: 502 return ret; 503 } 504 505 int ext4_readpage_inline(struct inode *inode, struct folio *folio) 506 { 507 int ret = 0; 508 509 down_read(&EXT4_I(inode)->xattr_sem); 510 if (!ext4_has_inline_data(inode)) { 511 up_read(&EXT4_I(inode)->xattr_sem); 512 return -EAGAIN; 513 } 514 515 /* 516 * Current inline data can only exist in the 1st page, 517 * So for all the other pages, just set them uptodate. 518 */ 519 if (!folio->index) 520 ret = ext4_read_inline_folio(inode, folio); 521 else if (!folio_test_uptodate(folio)) { 522 folio_zero_segment(folio, 0, folio_size(folio)); 523 folio_mark_uptodate(folio); 524 } 525 526 up_read(&EXT4_I(inode)->xattr_sem); 527 528 folio_unlock(folio); 529 return ret >= 0 ? 0 : ret; 530 } 531 532 static int ext4_convert_inline_data_to_extent(struct address_space *mapping, 533 struct inode *inode) 534 { 535 int ret, needed_blocks, no_expand; 536 handle_t *handle = NULL; 537 int retries = 0, sem_held = 0; 538 struct folio *folio = NULL; 539 unsigned from, to; 540 struct ext4_iloc iloc; 541 542 if (!ext4_has_inline_data(inode)) { 543 /* 544 * clear the flag so that no new write 545 * will trap here again. 546 */ 547 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 548 return 0; 549 } 550 551 needed_blocks = ext4_writepage_trans_blocks(inode); 552 553 ret = ext4_get_inode_loc(inode, &iloc); 554 if (ret) 555 return ret; 556 557 retry: 558 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 559 if (IS_ERR(handle)) { 560 ret = PTR_ERR(handle); 561 handle = NULL; 562 goto out; 563 } 564 565 /* We cannot recurse into the filesystem as the transaction is already 566 * started */ 567 folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS, 568 mapping_gfp_mask(mapping)); 569 if (IS_ERR(folio)) { 570 ret = PTR_ERR(folio); 571 goto out_nofolio; 572 } 573 574 ext4_write_lock_xattr(inode, &no_expand); 575 sem_held = 1; 576 /* If some one has already done this for us, just exit. */ 577 if (!ext4_has_inline_data(inode)) { 578 ret = 0; 579 goto out; 580 } 581 582 from = 0; 583 to = ext4_get_inline_size(inode); 584 if (!folio_test_uptodate(folio)) { 585 ret = ext4_read_inline_folio(inode, folio); 586 if (ret < 0) 587 goto out; 588 } 589 590 ret = ext4_destroy_inline_data_nolock(handle, inode); 591 if (ret) 592 goto out; 593 594 if (ext4_should_dioread_nolock(inode)) { 595 ret = __block_write_begin(&folio->page, from, to, 596 ext4_get_block_unwritten); 597 } else 598 ret = __block_write_begin(&folio->page, from, to, ext4_get_block); 599 600 if (!ret && ext4_should_journal_data(inode)) { 601 ret = ext4_walk_page_buffers(handle, inode, 602 folio_buffers(folio), from, to, 603 NULL, do_journal_get_write_access); 604 } 605 606 if (ret) { 607 folio_unlock(folio); 608 folio_put(folio); 609 folio = NULL; 610 ext4_orphan_add(handle, inode); 611 ext4_write_unlock_xattr(inode, &no_expand); 612 sem_held = 0; 613 ext4_journal_stop(handle); 614 handle = NULL; 615 ext4_truncate_failed_write(inode); 616 /* 617 * If truncate failed early the inode might 618 * still be on the orphan list; we need to 619 * make sure the inode is removed from the 620 * orphan list in that case. 621 */ 622 if (inode->i_nlink) 623 ext4_orphan_del(NULL, inode); 624 } 625 626 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 627 goto retry; 628 629 if (folio) 630 block_commit_write(&folio->page, from, to); 631 out: 632 if (folio) { 633 folio_unlock(folio); 634 folio_put(folio); 635 } 636 out_nofolio: 637 if (sem_held) 638 ext4_write_unlock_xattr(inode, &no_expand); 639 if (handle) 640 ext4_journal_stop(handle); 641 brelse(iloc.bh); 642 return ret; 643 } 644 645 /* 646 * Try to write data in the inode. 647 * If the inode has inline data, check whether the new write can be 648 * in the inode also. If not, create the page the handle, move the data 649 * to the page make it update and let the later codes create extent for it. 650 */ 651 int ext4_try_to_write_inline_data(struct address_space *mapping, 652 struct inode *inode, 653 loff_t pos, unsigned len, 654 struct page **pagep) 655 { 656 int ret; 657 handle_t *handle; 658 struct folio *folio; 659 struct ext4_iloc iloc; 660 661 if (pos + len > ext4_get_max_inline_size(inode)) 662 goto convert; 663 664 ret = ext4_get_inode_loc(inode, &iloc); 665 if (ret) 666 return ret; 667 668 /* 669 * The possible write could happen in the inode, 670 * so try to reserve the space in inode first. 671 */ 672 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 673 if (IS_ERR(handle)) { 674 ret = PTR_ERR(handle); 675 handle = NULL; 676 goto out; 677 } 678 679 ret = ext4_prepare_inline_data(handle, inode, pos + len); 680 if (ret && ret != -ENOSPC) 681 goto out; 682 683 /* We don't have space in inline inode, so convert it to extent. */ 684 if (ret == -ENOSPC) { 685 ext4_journal_stop(handle); 686 brelse(iloc.bh); 687 goto convert; 688 } 689 690 ret = ext4_journal_get_write_access(handle, inode->i_sb, iloc.bh, 691 EXT4_JTR_NONE); 692 if (ret) 693 goto out; 694 695 folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS, 696 mapping_gfp_mask(mapping)); 697 if (IS_ERR(folio)) { 698 ret = PTR_ERR(folio); 699 goto out; 700 } 701 702 *pagep = &folio->page; 703 down_read(&EXT4_I(inode)->xattr_sem); 704 if (!ext4_has_inline_data(inode)) { 705 ret = 0; 706 folio_unlock(folio); 707 folio_put(folio); 708 goto out_up_read; 709 } 710 711 if (!folio_test_uptodate(folio)) { 712 ret = ext4_read_inline_folio(inode, folio); 713 if (ret < 0) { 714 folio_unlock(folio); 715 folio_put(folio); 716 goto out_up_read; 717 } 718 } 719 720 ret = 1; 721 handle = NULL; 722 out_up_read: 723 up_read(&EXT4_I(inode)->xattr_sem); 724 out: 725 if (handle && (ret != 1)) 726 ext4_journal_stop(handle); 727 brelse(iloc.bh); 728 return ret; 729 convert: 730 return ext4_convert_inline_data_to_extent(mapping, inode); 731 } 732 733 int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len, 734 unsigned copied, struct page *page) 735 { 736 struct folio *folio = page_folio(page); 737 handle_t *handle = ext4_journal_current_handle(); 738 int no_expand; 739 void *kaddr; 740 struct ext4_iloc iloc; 741 int ret = 0, ret2; 742 743 if (unlikely(copied < len) && !folio_test_uptodate(folio)) 744 copied = 0; 745 746 if (likely(copied)) { 747 ret = ext4_get_inode_loc(inode, &iloc); 748 if (ret) { 749 folio_unlock(folio); 750 folio_put(folio); 751 ext4_std_error(inode->i_sb, ret); 752 goto out; 753 } 754 ext4_write_lock_xattr(inode, &no_expand); 755 BUG_ON(!ext4_has_inline_data(inode)); 756 757 /* 758 * ei->i_inline_off may have changed since 759 * ext4_write_begin() called 760 * ext4_try_to_write_inline_data() 761 */ 762 (void) ext4_find_inline_data_nolock(inode); 763 764 kaddr = kmap_local_folio(folio, 0); 765 ext4_write_inline_data(inode, &iloc, kaddr, pos, copied); 766 kunmap_local(kaddr); 767 folio_mark_uptodate(folio); 768 /* clear dirty flag so that writepages wouldn't work for us. */ 769 folio_clear_dirty(folio); 770 771 ext4_write_unlock_xattr(inode, &no_expand); 772 brelse(iloc.bh); 773 774 /* 775 * It's important to update i_size while still holding folio 776 * lock: page writeout could otherwise come in and zero 777 * beyond i_size. 778 */ 779 ext4_update_inode_size(inode, pos + copied); 780 } 781 folio_unlock(folio); 782 folio_put(folio); 783 784 /* 785 * Don't mark the inode dirty under folio lock. First, it unnecessarily 786 * makes the holding time of folio lock longer. Second, it forces lock 787 * ordering of folio lock and transaction start for journaling 788 * filesystems. 789 */ 790 if (likely(copied)) 791 mark_inode_dirty(inode); 792 out: 793 /* 794 * If we didn't copy as much data as expected, we need to trim back 795 * size of xattr containing inline data. 796 */ 797 if (pos + len > inode->i_size && ext4_can_truncate(inode)) 798 ext4_orphan_add(handle, inode); 799 800 ret2 = ext4_journal_stop(handle); 801 if (!ret) 802 ret = ret2; 803 if (pos + len > inode->i_size) { 804 ext4_truncate_failed_write(inode); 805 /* 806 * If truncate failed early the inode might still be 807 * on the orphan list; we need to make sure the inode 808 * is removed from the orphan list in that case. 809 */ 810 if (inode->i_nlink) 811 ext4_orphan_del(NULL, inode); 812 } 813 return ret ? ret : copied; 814 } 815 816 struct buffer_head * 817 ext4_journalled_write_inline_data(struct inode *inode, 818 unsigned len, 819 struct page *page) 820 { 821 int ret, no_expand; 822 void *kaddr; 823 struct ext4_iloc iloc; 824 825 ret = ext4_get_inode_loc(inode, &iloc); 826 if (ret) { 827 ext4_std_error(inode->i_sb, ret); 828 return NULL; 829 } 830 831 ext4_write_lock_xattr(inode, &no_expand); 832 kaddr = kmap_atomic(page); 833 ext4_write_inline_data(inode, &iloc, kaddr, 0, len); 834 kunmap_atomic(kaddr); 835 ext4_write_unlock_xattr(inode, &no_expand); 836 837 return iloc.bh; 838 } 839 840 /* 841 * Try to make the page cache and handle ready for the inline data case. 842 * We can call this function in 2 cases: 843 * 1. The inode is created and the first write exceeds inline size. We can 844 * clear the inode state safely. 845 * 2. The inode has inline data, then we need to read the data, make it 846 * update and dirty so that ext4_da_writepages can handle it. We don't 847 * need to start the journal since the file's metadata isn't changed now. 848 */ 849 static int ext4_da_convert_inline_data_to_extent(struct address_space *mapping, 850 struct inode *inode, 851 void **fsdata) 852 { 853 int ret = 0, inline_size; 854 struct folio *folio; 855 856 folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN, 857 mapping_gfp_mask(mapping)); 858 if (IS_ERR(folio)) 859 return PTR_ERR(folio); 860 861 down_read(&EXT4_I(inode)->xattr_sem); 862 if (!ext4_has_inline_data(inode)) { 863 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 864 goto out; 865 } 866 867 inline_size = ext4_get_inline_size(inode); 868 869 if (!folio_test_uptodate(folio)) { 870 ret = ext4_read_inline_folio(inode, folio); 871 if (ret < 0) 872 goto out; 873 } 874 875 ret = __block_write_begin(&folio->page, 0, inline_size, 876 ext4_da_get_block_prep); 877 if (ret) { 878 up_read(&EXT4_I(inode)->xattr_sem); 879 folio_unlock(folio); 880 folio_put(folio); 881 ext4_truncate_failed_write(inode); 882 return ret; 883 } 884 885 folio_mark_dirty(folio); 886 folio_mark_uptodate(folio); 887 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 888 *fsdata = (void *)CONVERT_INLINE_DATA; 889 890 out: 891 up_read(&EXT4_I(inode)->xattr_sem); 892 if (folio) { 893 folio_unlock(folio); 894 folio_put(folio); 895 } 896 return ret; 897 } 898 899 /* 900 * Prepare the write for the inline data. 901 * If the data can be written into the inode, we just read 902 * the page and make it uptodate, and start the journal. 903 * Otherwise read the page, makes it dirty so that it can be 904 * handle in writepages(the i_disksize update is left to the 905 * normal ext4_da_write_end). 906 */ 907 int ext4_da_write_inline_data_begin(struct address_space *mapping, 908 struct inode *inode, 909 loff_t pos, unsigned len, 910 struct page **pagep, 911 void **fsdata) 912 { 913 int ret; 914 handle_t *handle; 915 struct folio *folio; 916 struct ext4_iloc iloc; 917 int retries = 0; 918 919 ret = ext4_get_inode_loc(inode, &iloc); 920 if (ret) 921 return ret; 922 923 retry_journal: 924 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 925 if (IS_ERR(handle)) { 926 ret = PTR_ERR(handle); 927 goto out; 928 } 929 930 ret = ext4_prepare_inline_data(handle, inode, pos + len); 931 if (ret && ret != -ENOSPC) 932 goto out_journal; 933 934 if (ret == -ENOSPC) { 935 ext4_journal_stop(handle); 936 ret = ext4_da_convert_inline_data_to_extent(mapping, 937 inode, 938 fsdata); 939 if (ret == -ENOSPC && 940 ext4_should_retry_alloc(inode->i_sb, &retries)) 941 goto retry_journal; 942 goto out; 943 } 944 945 /* 946 * We cannot recurse into the filesystem as the transaction 947 * is already started. 948 */ 949 folio = __filemap_get_folio(mapping, 0, FGP_WRITEBEGIN | FGP_NOFS, 950 mapping_gfp_mask(mapping)); 951 if (IS_ERR(folio)) { 952 ret = PTR_ERR(folio); 953 goto out_journal; 954 } 955 956 down_read(&EXT4_I(inode)->xattr_sem); 957 if (!ext4_has_inline_data(inode)) { 958 ret = 0; 959 goto out_release_page; 960 } 961 962 if (!folio_test_uptodate(folio)) { 963 ret = ext4_read_inline_folio(inode, folio); 964 if (ret < 0) 965 goto out_release_page; 966 } 967 ret = ext4_journal_get_write_access(handle, inode->i_sb, iloc.bh, 968 EXT4_JTR_NONE); 969 if (ret) 970 goto out_release_page; 971 972 up_read(&EXT4_I(inode)->xattr_sem); 973 *pagep = &folio->page; 974 brelse(iloc.bh); 975 return 1; 976 out_release_page: 977 up_read(&EXT4_I(inode)->xattr_sem); 978 folio_unlock(folio); 979 folio_put(folio); 980 out_journal: 981 ext4_journal_stop(handle); 982 out: 983 brelse(iloc.bh); 984 return ret; 985 } 986 987 #ifdef INLINE_DIR_DEBUG 988 void ext4_show_inline_dir(struct inode *dir, struct buffer_head *bh, 989 void *inline_start, int inline_size) 990 { 991 int offset; 992 unsigned short de_len; 993 struct ext4_dir_entry_2 *de = inline_start; 994 void *dlimit = inline_start + inline_size; 995 996 trace_printk("inode %lu\n", dir->i_ino); 997 offset = 0; 998 while ((void *)de < dlimit) { 999 de_len = ext4_rec_len_from_disk(de->rec_len, inline_size); 1000 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n", 1001 offset, de_len, de->name_len, de->name, 1002 de->name_len, le32_to_cpu(de->inode)); 1003 if (ext4_check_dir_entry(dir, NULL, de, bh, 1004 inline_start, inline_size, offset)) 1005 BUG(); 1006 1007 offset += de_len; 1008 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len); 1009 } 1010 } 1011 #else 1012 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size) 1013 #endif 1014 1015 /* 1016 * Add a new entry into a inline dir. 1017 * It will return -ENOSPC if no space is available, and -EIO 1018 * and -EEXIST if directory entry already exists. 1019 */ 1020 static int ext4_add_dirent_to_inline(handle_t *handle, 1021 struct ext4_filename *fname, 1022 struct inode *dir, 1023 struct inode *inode, 1024 struct ext4_iloc *iloc, 1025 void *inline_start, int inline_size) 1026 { 1027 int err; 1028 struct ext4_dir_entry_2 *de; 1029 1030 err = ext4_find_dest_de(dir, inode, iloc->bh, inline_start, 1031 inline_size, fname, &de); 1032 if (err) 1033 return err; 1034 1035 BUFFER_TRACE(iloc->bh, "get_write_access"); 1036 err = ext4_journal_get_write_access(handle, dir->i_sb, iloc->bh, 1037 EXT4_JTR_NONE); 1038 if (err) 1039 return err; 1040 ext4_insert_dentry(dir, inode, de, inline_size, fname); 1041 1042 ext4_show_inline_dir(dir, iloc->bh, inline_start, inline_size); 1043 1044 /* 1045 * XXX shouldn't update any times until successful 1046 * completion of syscall, but too many callers depend 1047 * on this. 1048 * 1049 * XXX similarly, too many callers depend on 1050 * ext4_new_inode() setting the times, but error 1051 * recovery deletes the inode, so the worst that can 1052 * happen is that the times are slightly out of date 1053 * and/or different from the directory change time. 1054 */ 1055 dir->i_mtime = dir->i_ctime = current_time(dir); 1056 ext4_update_dx_flag(dir); 1057 inode_inc_iversion(dir); 1058 return 1; 1059 } 1060 1061 static void *ext4_get_inline_xattr_pos(struct inode *inode, 1062 struct ext4_iloc *iloc) 1063 { 1064 struct ext4_xattr_entry *entry; 1065 struct ext4_xattr_ibody_header *header; 1066 1067 BUG_ON(!EXT4_I(inode)->i_inline_off); 1068 1069 header = IHDR(inode, ext4_raw_inode(iloc)); 1070 entry = (struct ext4_xattr_entry *)((void *)ext4_raw_inode(iloc) + 1071 EXT4_I(inode)->i_inline_off); 1072 1073 return (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs); 1074 } 1075 1076 /* Set the final de to cover the whole block. */ 1077 static void ext4_update_final_de(void *de_buf, int old_size, int new_size) 1078 { 1079 struct ext4_dir_entry_2 *de, *prev_de; 1080 void *limit; 1081 int de_len; 1082 1083 de = de_buf; 1084 if (old_size) { 1085 limit = de_buf + old_size; 1086 do { 1087 prev_de = de; 1088 de_len = ext4_rec_len_from_disk(de->rec_len, old_size); 1089 de_buf += de_len; 1090 de = de_buf; 1091 } while (de_buf < limit); 1092 1093 prev_de->rec_len = ext4_rec_len_to_disk(de_len + new_size - 1094 old_size, new_size); 1095 } else { 1096 /* this is just created, so create an empty entry. */ 1097 de->inode = 0; 1098 de->rec_len = ext4_rec_len_to_disk(new_size, new_size); 1099 } 1100 } 1101 1102 static int ext4_update_inline_dir(handle_t *handle, struct inode *dir, 1103 struct ext4_iloc *iloc) 1104 { 1105 int ret; 1106 int old_size = EXT4_I(dir)->i_inline_size - EXT4_MIN_INLINE_DATA_SIZE; 1107 int new_size = get_max_inline_xattr_value_size(dir, iloc); 1108 1109 if (new_size - old_size <= ext4_dir_rec_len(1, NULL)) 1110 return -ENOSPC; 1111 1112 ret = ext4_update_inline_data(handle, dir, 1113 new_size + EXT4_MIN_INLINE_DATA_SIZE); 1114 if (ret) 1115 return ret; 1116 1117 ext4_update_final_de(ext4_get_inline_xattr_pos(dir, iloc), old_size, 1118 EXT4_I(dir)->i_inline_size - 1119 EXT4_MIN_INLINE_DATA_SIZE); 1120 dir->i_size = EXT4_I(dir)->i_disksize = EXT4_I(dir)->i_inline_size; 1121 return 0; 1122 } 1123 1124 static void ext4_restore_inline_data(handle_t *handle, struct inode *inode, 1125 struct ext4_iloc *iloc, 1126 void *buf, int inline_size) 1127 { 1128 int ret; 1129 1130 ret = ext4_create_inline_data(handle, inode, inline_size); 1131 if (ret) { 1132 ext4_msg(inode->i_sb, KERN_EMERG, 1133 "error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)", 1134 inode->i_ino, ret); 1135 return; 1136 } 1137 ext4_write_inline_data(inode, iloc, buf, 0, inline_size); 1138 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 1139 } 1140 1141 static int ext4_finish_convert_inline_dir(handle_t *handle, 1142 struct inode *inode, 1143 struct buffer_head *dir_block, 1144 void *buf, 1145 int inline_size) 1146 { 1147 int err, csum_size = 0, header_size = 0; 1148 struct ext4_dir_entry_2 *de; 1149 void *target = dir_block->b_data; 1150 1151 /* 1152 * First create "." and ".." and then copy the dir information 1153 * back to the block. 1154 */ 1155 de = target; 1156 de = ext4_init_dot_dotdot(inode, de, 1157 inode->i_sb->s_blocksize, csum_size, 1158 le32_to_cpu(((struct ext4_dir_entry_2 *)buf)->inode), 1); 1159 header_size = (void *)de - target; 1160 1161 memcpy((void *)de, buf + EXT4_INLINE_DOTDOT_SIZE, 1162 inline_size - EXT4_INLINE_DOTDOT_SIZE); 1163 1164 if (ext4_has_metadata_csum(inode->i_sb)) 1165 csum_size = sizeof(struct ext4_dir_entry_tail); 1166 1167 inode->i_size = inode->i_sb->s_blocksize; 1168 i_size_write(inode, inode->i_sb->s_blocksize); 1169 EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize; 1170 ext4_update_final_de(dir_block->b_data, 1171 inline_size - EXT4_INLINE_DOTDOT_SIZE + header_size, 1172 inode->i_sb->s_blocksize - csum_size); 1173 1174 if (csum_size) 1175 ext4_initialize_dirent_tail(dir_block, 1176 inode->i_sb->s_blocksize); 1177 set_buffer_uptodate(dir_block); 1178 err = ext4_handle_dirty_dirblock(handle, inode, dir_block); 1179 if (err) 1180 return err; 1181 set_buffer_verified(dir_block); 1182 return ext4_mark_inode_dirty(handle, inode); 1183 } 1184 1185 static int ext4_convert_inline_data_nolock(handle_t *handle, 1186 struct inode *inode, 1187 struct ext4_iloc *iloc) 1188 { 1189 int error; 1190 void *buf = NULL; 1191 struct buffer_head *data_bh = NULL; 1192 struct ext4_map_blocks map; 1193 int inline_size; 1194 1195 inline_size = ext4_get_inline_size(inode); 1196 buf = kmalloc(inline_size, GFP_NOFS); 1197 if (!buf) { 1198 error = -ENOMEM; 1199 goto out; 1200 } 1201 1202 error = ext4_read_inline_data(inode, buf, inline_size, iloc); 1203 if (error < 0) 1204 goto out; 1205 1206 /* 1207 * Make sure the inline directory entries pass checks before we try to 1208 * convert them, so that we avoid touching stuff that needs fsck. 1209 */ 1210 if (S_ISDIR(inode->i_mode)) { 1211 error = ext4_check_all_de(inode, iloc->bh, 1212 buf + EXT4_INLINE_DOTDOT_SIZE, 1213 inline_size - EXT4_INLINE_DOTDOT_SIZE); 1214 if (error) 1215 goto out; 1216 } 1217 1218 error = ext4_destroy_inline_data_nolock(handle, inode); 1219 if (error) 1220 goto out; 1221 1222 map.m_lblk = 0; 1223 map.m_len = 1; 1224 map.m_flags = 0; 1225 error = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_CREATE); 1226 if (error < 0) 1227 goto out_restore; 1228 if (!(map.m_flags & EXT4_MAP_MAPPED)) { 1229 error = -EIO; 1230 goto out_restore; 1231 } 1232 1233 data_bh = sb_getblk(inode->i_sb, map.m_pblk); 1234 if (!data_bh) { 1235 error = -ENOMEM; 1236 goto out_restore; 1237 } 1238 1239 lock_buffer(data_bh); 1240 error = ext4_journal_get_create_access(handle, inode->i_sb, data_bh, 1241 EXT4_JTR_NONE); 1242 if (error) { 1243 unlock_buffer(data_bh); 1244 error = -EIO; 1245 goto out_restore; 1246 } 1247 memset(data_bh->b_data, 0, inode->i_sb->s_blocksize); 1248 1249 if (!S_ISDIR(inode->i_mode)) { 1250 memcpy(data_bh->b_data, buf, inline_size); 1251 set_buffer_uptodate(data_bh); 1252 error = ext4_handle_dirty_metadata(handle, 1253 inode, data_bh); 1254 } else { 1255 error = ext4_finish_convert_inline_dir(handle, inode, data_bh, 1256 buf, inline_size); 1257 } 1258 1259 unlock_buffer(data_bh); 1260 out_restore: 1261 if (error) 1262 ext4_restore_inline_data(handle, inode, iloc, buf, inline_size); 1263 1264 out: 1265 brelse(data_bh); 1266 kfree(buf); 1267 return error; 1268 } 1269 1270 /* 1271 * Try to add the new entry to the inline data. 1272 * If succeeds, return 0. If not, extended the inline dir and copied data to 1273 * the new created block. 1274 */ 1275 int ext4_try_add_inline_entry(handle_t *handle, struct ext4_filename *fname, 1276 struct inode *dir, struct inode *inode) 1277 { 1278 int ret, ret2, inline_size, no_expand; 1279 void *inline_start; 1280 struct ext4_iloc iloc; 1281 1282 ret = ext4_get_inode_loc(dir, &iloc); 1283 if (ret) 1284 return ret; 1285 1286 ext4_write_lock_xattr(dir, &no_expand); 1287 if (!ext4_has_inline_data(dir)) 1288 goto out; 1289 1290 inline_start = (void *)ext4_raw_inode(&iloc)->i_block + 1291 EXT4_INLINE_DOTDOT_SIZE; 1292 inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE; 1293 1294 ret = ext4_add_dirent_to_inline(handle, fname, dir, inode, &iloc, 1295 inline_start, inline_size); 1296 if (ret != -ENOSPC) 1297 goto out; 1298 1299 /* check whether it can be inserted to inline xattr space. */ 1300 inline_size = EXT4_I(dir)->i_inline_size - 1301 EXT4_MIN_INLINE_DATA_SIZE; 1302 if (!inline_size) { 1303 /* Try to use the xattr space.*/ 1304 ret = ext4_update_inline_dir(handle, dir, &iloc); 1305 if (ret && ret != -ENOSPC) 1306 goto out; 1307 1308 inline_size = EXT4_I(dir)->i_inline_size - 1309 EXT4_MIN_INLINE_DATA_SIZE; 1310 } 1311 1312 if (inline_size) { 1313 inline_start = ext4_get_inline_xattr_pos(dir, &iloc); 1314 1315 ret = ext4_add_dirent_to_inline(handle, fname, dir, 1316 inode, &iloc, inline_start, 1317 inline_size); 1318 1319 if (ret != -ENOSPC) 1320 goto out; 1321 } 1322 1323 /* 1324 * The inline space is filled up, so create a new block for it. 1325 * As the extent tree will be created, we have to save the inline 1326 * dir first. 1327 */ 1328 ret = ext4_convert_inline_data_nolock(handle, dir, &iloc); 1329 1330 out: 1331 ext4_write_unlock_xattr(dir, &no_expand); 1332 ret2 = ext4_mark_inode_dirty(handle, dir); 1333 if (unlikely(ret2 && !ret)) 1334 ret = ret2; 1335 brelse(iloc.bh); 1336 return ret; 1337 } 1338 1339 /* 1340 * This function fills a red-black tree with information from an 1341 * inlined dir. It returns the number directory entries loaded 1342 * into the tree. If there is an error it is returned in err. 1343 */ 1344 int ext4_inlinedir_to_tree(struct file *dir_file, 1345 struct inode *dir, ext4_lblk_t block, 1346 struct dx_hash_info *hinfo, 1347 __u32 start_hash, __u32 start_minor_hash, 1348 int *has_inline_data) 1349 { 1350 int err = 0, count = 0; 1351 unsigned int parent_ino; 1352 int pos; 1353 struct ext4_dir_entry_2 *de; 1354 struct inode *inode = file_inode(dir_file); 1355 int ret, inline_size = 0; 1356 struct ext4_iloc iloc; 1357 void *dir_buf = NULL; 1358 struct ext4_dir_entry_2 fake; 1359 struct fscrypt_str tmp_str; 1360 1361 ret = ext4_get_inode_loc(inode, &iloc); 1362 if (ret) 1363 return ret; 1364 1365 down_read(&EXT4_I(inode)->xattr_sem); 1366 if (!ext4_has_inline_data(inode)) { 1367 up_read(&EXT4_I(inode)->xattr_sem); 1368 *has_inline_data = 0; 1369 goto out; 1370 } 1371 1372 inline_size = ext4_get_inline_size(inode); 1373 dir_buf = kmalloc(inline_size, GFP_NOFS); 1374 if (!dir_buf) { 1375 ret = -ENOMEM; 1376 up_read(&EXT4_I(inode)->xattr_sem); 1377 goto out; 1378 } 1379 1380 ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc); 1381 up_read(&EXT4_I(inode)->xattr_sem); 1382 if (ret < 0) 1383 goto out; 1384 1385 pos = 0; 1386 parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode); 1387 while (pos < inline_size) { 1388 /* 1389 * As inlined dir doesn't store any information about '.' and 1390 * only the inode number of '..' is stored, we have to handle 1391 * them differently. 1392 */ 1393 if (pos == 0) { 1394 fake.inode = cpu_to_le32(inode->i_ino); 1395 fake.name_len = 1; 1396 strcpy(fake.name, "."); 1397 fake.rec_len = ext4_rec_len_to_disk( 1398 ext4_dir_rec_len(fake.name_len, NULL), 1399 inline_size); 1400 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); 1401 de = &fake; 1402 pos = EXT4_INLINE_DOTDOT_OFFSET; 1403 } else if (pos == EXT4_INLINE_DOTDOT_OFFSET) { 1404 fake.inode = cpu_to_le32(parent_ino); 1405 fake.name_len = 2; 1406 strcpy(fake.name, ".."); 1407 fake.rec_len = ext4_rec_len_to_disk( 1408 ext4_dir_rec_len(fake.name_len, NULL), 1409 inline_size); 1410 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); 1411 de = &fake; 1412 pos = EXT4_INLINE_DOTDOT_SIZE; 1413 } else { 1414 de = (struct ext4_dir_entry_2 *)(dir_buf + pos); 1415 pos += ext4_rec_len_from_disk(de->rec_len, inline_size); 1416 if (ext4_check_dir_entry(inode, dir_file, de, 1417 iloc.bh, dir_buf, 1418 inline_size, pos)) { 1419 ret = count; 1420 goto out; 1421 } 1422 } 1423 1424 if (ext4_hash_in_dirent(dir)) { 1425 hinfo->hash = EXT4_DIRENT_HASH(de); 1426 hinfo->minor_hash = EXT4_DIRENT_MINOR_HASH(de); 1427 } else { 1428 ext4fs_dirhash(dir, de->name, de->name_len, hinfo); 1429 } 1430 if ((hinfo->hash < start_hash) || 1431 ((hinfo->hash == start_hash) && 1432 (hinfo->minor_hash < start_minor_hash))) 1433 continue; 1434 if (de->inode == 0) 1435 continue; 1436 tmp_str.name = de->name; 1437 tmp_str.len = de->name_len; 1438 err = ext4_htree_store_dirent(dir_file, hinfo->hash, 1439 hinfo->minor_hash, de, &tmp_str); 1440 if (err) { 1441 ret = err; 1442 goto out; 1443 } 1444 count++; 1445 } 1446 ret = count; 1447 out: 1448 kfree(dir_buf); 1449 brelse(iloc.bh); 1450 return ret; 1451 } 1452 1453 /* 1454 * So this function is called when the volume is mkfsed with 1455 * dir_index disabled. In order to keep f_pos persistent 1456 * after we convert from an inlined dir to a blocked based, 1457 * we just pretend that we are a normal dir and return the 1458 * offset as if '.' and '..' really take place. 1459 * 1460 */ 1461 int ext4_read_inline_dir(struct file *file, 1462 struct dir_context *ctx, 1463 int *has_inline_data) 1464 { 1465 unsigned int offset, parent_ino; 1466 int i; 1467 struct ext4_dir_entry_2 *de; 1468 struct super_block *sb; 1469 struct inode *inode = file_inode(file); 1470 int ret, inline_size = 0; 1471 struct ext4_iloc iloc; 1472 void *dir_buf = NULL; 1473 int dotdot_offset, dotdot_size, extra_offset, extra_size; 1474 1475 ret = ext4_get_inode_loc(inode, &iloc); 1476 if (ret) 1477 return ret; 1478 1479 down_read(&EXT4_I(inode)->xattr_sem); 1480 if (!ext4_has_inline_data(inode)) { 1481 up_read(&EXT4_I(inode)->xattr_sem); 1482 *has_inline_data = 0; 1483 goto out; 1484 } 1485 1486 inline_size = ext4_get_inline_size(inode); 1487 dir_buf = kmalloc(inline_size, GFP_NOFS); 1488 if (!dir_buf) { 1489 ret = -ENOMEM; 1490 up_read(&EXT4_I(inode)->xattr_sem); 1491 goto out; 1492 } 1493 1494 ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc); 1495 up_read(&EXT4_I(inode)->xattr_sem); 1496 if (ret < 0) 1497 goto out; 1498 1499 ret = 0; 1500 sb = inode->i_sb; 1501 parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode); 1502 offset = ctx->pos; 1503 1504 /* 1505 * dotdot_offset and dotdot_size is the real offset and 1506 * size for ".." and "." if the dir is block based while 1507 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE. 1508 * So we will use extra_offset and extra_size to indicate them 1509 * during the inline dir iteration. 1510 */ 1511 dotdot_offset = ext4_dir_rec_len(1, NULL); 1512 dotdot_size = dotdot_offset + ext4_dir_rec_len(2, NULL); 1513 extra_offset = dotdot_size - EXT4_INLINE_DOTDOT_SIZE; 1514 extra_size = extra_offset + inline_size; 1515 1516 /* 1517 * If the version has changed since the last call to 1518 * readdir(2), then we might be pointing to an invalid 1519 * dirent right now. Scan from the start of the inline 1520 * dir to make sure. 1521 */ 1522 if (!inode_eq_iversion(inode, file->f_version)) { 1523 for (i = 0; i < extra_size && i < offset;) { 1524 /* 1525 * "." is with offset 0 and 1526 * ".." is dotdot_offset. 1527 */ 1528 if (!i) { 1529 i = dotdot_offset; 1530 continue; 1531 } else if (i == dotdot_offset) { 1532 i = dotdot_size; 1533 continue; 1534 } 1535 /* for other entry, the real offset in 1536 * the buf has to be tuned accordingly. 1537 */ 1538 de = (struct ext4_dir_entry_2 *) 1539 (dir_buf + i - extra_offset); 1540 /* It's too expensive to do a full 1541 * dirent test each time round this 1542 * loop, but we do have to test at 1543 * least that it is non-zero. A 1544 * failure will be detected in the 1545 * dirent test below. */ 1546 if (ext4_rec_len_from_disk(de->rec_len, extra_size) 1547 < ext4_dir_rec_len(1, NULL)) 1548 break; 1549 i += ext4_rec_len_from_disk(de->rec_len, 1550 extra_size); 1551 } 1552 offset = i; 1553 ctx->pos = offset; 1554 file->f_version = inode_query_iversion(inode); 1555 } 1556 1557 while (ctx->pos < extra_size) { 1558 if (ctx->pos == 0) { 1559 if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR)) 1560 goto out; 1561 ctx->pos = dotdot_offset; 1562 continue; 1563 } 1564 1565 if (ctx->pos == dotdot_offset) { 1566 if (!dir_emit(ctx, "..", 2, parent_ino, DT_DIR)) 1567 goto out; 1568 ctx->pos = dotdot_size; 1569 continue; 1570 } 1571 1572 de = (struct ext4_dir_entry_2 *) 1573 (dir_buf + ctx->pos - extra_offset); 1574 if (ext4_check_dir_entry(inode, file, de, iloc.bh, dir_buf, 1575 extra_size, ctx->pos)) 1576 goto out; 1577 if (le32_to_cpu(de->inode)) { 1578 if (!dir_emit(ctx, de->name, de->name_len, 1579 le32_to_cpu(de->inode), 1580 get_dtype(sb, de->file_type))) 1581 goto out; 1582 } 1583 ctx->pos += ext4_rec_len_from_disk(de->rec_len, extra_size); 1584 } 1585 out: 1586 kfree(dir_buf); 1587 brelse(iloc.bh); 1588 return ret; 1589 } 1590 1591 void *ext4_read_inline_link(struct inode *inode) 1592 { 1593 struct ext4_iloc iloc; 1594 int ret, inline_size; 1595 void *link; 1596 1597 ret = ext4_get_inode_loc(inode, &iloc); 1598 if (ret) 1599 return ERR_PTR(ret); 1600 1601 ret = -ENOMEM; 1602 inline_size = ext4_get_inline_size(inode); 1603 link = kmalloc(inline_size + 1, GFP_NOFS); 1604 if (!link) 1605 goto out; 1606 1607 ret = ext4_read_inline_data(inode, link, inline_size, &iloc); 1608 if (ret < 0) { 1609 kfree(link); 1610 goto out; 1611 } 1612 nd_terminate_link(link, inode->i_size, ret); 1613 out: 1614 if (ret < 0) 1615 link = ERR_PTR(ret); 1616 brelse(iloc.bh); 1617 return link; 1618 } 1619 1620 struct buffer_head *ext4_get_first_inline_block(struct inode *inode, 1621 struct ext4_dir_entry_2 **parent_de, 1622 int *retval) 1623 { 1624 struct ext4_iloc iloc; 1625 1626 *retval = ext4_get_inode_loc(inode, &iloc); 1627 if (*retval) 1628 return NULL; 1629 1630 *parent_de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block; 1631 1632 return iloc.bh; 1633 } 1634 1635 /* 1636 * Try to create the inline data for the new dir. 1637 * If it succeeds, return 0, otherwise return the error. 1638 * In case of ENOSPC, the caller should create the normal disk layout dir. 1639 */ 1640 int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent, 1641 struct inode *inode) 1642 { 1643 int ret, inline_size = EXT4_MIN_INLINE_DATA_SIZE; 1644 struct ext4_iloc iloc; 1645 struct ext4_dir_entry_2 *de; 1646 1647 ret = ext4_get_inode_loc(inode, &iloc); 1648 if (ret) 1649 return ret; 1650 1651 ret = ext4_prepare_inline_data(handle, inode, inline_size); 1652 if (ret) 1653 goto out; 1654 1655 /* 1656 * For inline dir, we only save the inode information for the ".." 1657 * and create a fake dentry to cover the left space. 1658 */ 1659 de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block; 1660 de->inode = cpu_to_le32(parent->i_ino); 1661 de = (struct ext4_dir_entry_2 *)((void *)de + EXT4_INLINE_DOTDOT_SIZE); 1662 de->inode = 0; 1663 de->rec_len = ext4_rec_len_to_disk( 1664 inline_size - EXT4_INLINE_DOTDOT_SIZE, 1665 inline_size); 1666 set_nlink(inode, 2); 1667 inode->i_size = EXT4_I(inode)->i_disksize = inline_size; 1668 out: 1669 brelse(iloc.bh); 1670 return ret; 1671 } 1672 1673 struct buffer_head *ext4_find_inline_entry(struct inode *dir, 1674 struct ext4_filename *fname, 1675 struct ext4_dir_entry_2 **res_dir, 1676 int *has_inline_data) 1677 { 1678 int ret; 1679 struct ext4_iloc iloc; 1680 void *inline_start; 1681 int inline_size; 1682 1683 if (ext4_get_inode_loc(dir, &iloc)) 1684 return NULL; 1685 1686 down_read(&EXT4_I(dir)->xattr_sem); 1687 if (!ext4_has_inline_data(dir)) { 1688 *has_inline_data = 0; 1689 goto out; 1690 } 1691 1692 inline_start = (void *)ext4_raw_inode(&iloc)->i_block + 1693 EXT4_INLINE_DOTDOT_SIZE; 1694 inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE; 1695 ret = ext4_search_dir(iloc.bh, inline_start, inline_size, 1696 dir, fname, 0, res_dir); 1697 if (ret == 1) 1698 goto out_find; 1699 if (ret < 0) 1700 goto out; 1701 1702 if (ext4_get_inline_size(dir) == EXT4_MIN_INLINE_DATA_SIZE) 1703 goto out; 1704 1705 inline_start = ext4_get_inline_xattr_pos(dir, &iloc); 1706 inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE; 1707 1708 ret = ext4_search_dir(iloc.bh, inline_start, inline_size, 1709 dir, fname, 0, res_dir); 1710 if (ret == 1) 1711 goto out_find; 1712 1713 out: 1714 brelse(iloc.bh); 1715 iloc.bh = NULL; 1716 out_find: 1717 up_read(&EXT4_I(dir)->xattr_sem); 1718 return iloc.bh; 1719 } 1720 1721 int ext4_delete_inline_entry(handle_t *handle, 1722 struct inode *dir, 1723 struct ext4_dir_entry_2 *de_del, 1724 struct buffer_head *bh, 1725 int *has_inline_data) 1726 { 1727 int err, inline_size, no_expand; 1728 struct ext4_iloc iloc; 1729 void *inline_start; 1730 1731 err = ext4_get_inode_loc(dir, &iloc); 1732 if (err) 1733 return err; 1734 1735 ext4_write_lock_xattr(dir, &no_expand); 1736 if (!ext4_has_inline_data(dir)) { 1737 *has_inline_data = 0; 1738 goto out; 1739 } 1740 1741 if ((void *)de_del - ((void *)ext4_raw_inode(&iloc)->i_block) < 1742 EXT4_MIN_INLINE_DATA_SIZE) { 1743 inline_start = (void *)ext4_raw_inode(&iloc)->i_block + 1744 EXT4_INLINE_DOTDOT_SIZE; 1745 inline_size = EXT4_MIN_INLINE_DATA_SIZE - 1746 EXT4_INLINE_DOTDOT_SIZE; 1747 } else { 1748 inline_start = ext4_get_inline_xattr_pos(dir, &iloc); 1749 inline_size = ext4_get_inline_size(dir) - 1750 EXT4_MIN_INLINE_DATA_SIZE; 1751 } 1752 1753 BUFFER_TRACE(bh, "get_write_access"); 1754 err = ext4_journal_get_write_access(handle, dir->i_sb, bh, 1755 EXT4_JTR_NONE); 1756 if (err) 1757 goto out; 1758 1759 err = ext4_generic_delete_entry(dir, de_del, bh, 1760 inline_start, inline_size, 0); 1761 if (err) 1762 goto out; 1763 1764 ext4_show_inline_dir(dir, iloc.bh, inline_start, inline_size); 1765 out: 1766 ext4_write_unlock_xattr(dir, &no_expand); 1767 if (likely(err == 0)) 1768 err = ext4_mark_inode_dirty(handle, dir); 1769 brelse(iloc.bh); 1770 if (err != -ENOENT) 1771 ext4_std_error(dir->i_sb, err); 1772 return err; 1773 } 1774 1775 /* 1776 * Get the inline dentry at offset. 1777 */ 1778 static inline struct ext4_dir_entry_2 * 1779 ext4_get_inline_entry(struct inode *inode, 1780 struct ext4_iloc *iloc, 1781 unsigned int offset, 1782 void **inline_start, 1783 int *inline_size) 1784 { 1785 void *inline_pos; 1786 1787 BUG_ON(offset > ext4_get_inline_size(inode)); 1788 1789 if (offset < EXT4_MIN_INLINE_DATA_SIZE) { 1790 inline_pos = (void *)ext4_raw_inode(iloc)->i_block; 1791 *inline_size = EXT4_MIN_INLINE_DATA_SIZE; 1792 } else { 1793 inline_pos = ext4_get_inline_xattr_pos(inode, iloc); 1794 offset -= EXT4_MIN_INLINE_DATA_SIZE; 1795 *inline_size = ext4_get_inline_size(inode) - 1796 EXT4_MIN_INLINE_DATA_SIZE; 1797 } 1798 1799 if (inline_start) 1800 *inline_start = inline_pos; 1801 return (struct ext4_dir_entry_2 *)(inline_pos + offset); 1802 } 1803 1804 bool empty_inline_dir(struct inode *dir, int *has_inline_data) 1805 { 1806 int err, inline_size; 1807 struct ext4_iloc iloc; 1808 size_t inline_len; 1809 void *inline_pos; 1810 unsigned int offset; 1811 struct ext4_dir_entry_2 *de; 1812 bool ret = false; 1813 1814 err = ext4_get_inode_loc(dir, &iloc); 1815 if (err) { 1816 EXT4_ERROR_INODE_ERR(dir, -err, 1817 "error %d getting inode %lu block", 1818 err, dir->i_ino); 1819 return false; 1820 } 1821 1822 down_read(&EXT4_I(dir)->xattr_sem); 1823 if (!ext4_has_inline_data(dir)) { 1824 *has_inline_data = 0; 1825 ret = true; 1826 goto out; 1827 } 1828 1829 de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block; 1830 if (!le32_to_cpu(de->inode)) { 1831 ext4_warning(dir->i_sb, 1832 "bad inline directory (dir #%lu) - no `..'", 1833 dir->i_ino); 1834 goto out; 1835 } 1836 1837 inline_len = ext4_get_inline_size(dir); 1838 offset = EXT4_INLINE_DOTDOT_SIZE; 1839 while (offset < inline_len) { 1840 de = ext4_get_inline_entry(dir, &iloc, offset, 1841 &inline_pos, &inline_size); 1842 if (ext4_check_dir_entry(dir, NULL, de, 1843 iloc.bh, inline_pos, 1844 inline_size, offset)) { 1845 ext4_warning(dir->i_sb, 1846 "bad inline directory (dir #%lu) - " 1847 "inode %u, rec_len %u, name_len %d" 1848 "inline size %d", 1849 dir->i_ino, le32_to_cpu(de->inode), 1850 le16_to_cpu(de->rec_len), de->name_len, 1851 inline_size); 1852 goto out; 1853 } 1854 if (le32_to_cpu(de->inode)) { 1855 goto out; 1856 } 1857 offset += ext4_rec_len_from_disk(de->rec_len, inline_size); 1858 } 1859 1860 ret = true; 1861 out: 1862 up_read(&EXT4_I(dir)->xattr_sem); 1863 brelse(iloc.bh); 1864 return ret; 1865 } 1866 1867 int ext4_destroy_inline_data(handle_t *handle, struct inode *inode) 1868 { 1869 int ret, no_expand; 1870 1871 ext4_write_lock_xattr(inode, &no_expand); 1872 ret = ext4_destroy_inline_data_nolock(handle, inode); 1873 ext4_write_unlock_xattr(inode, &no_expand); 1874 1875 return ret; 1876 } 1877 1878 int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap) 1879 { 1880 __u64 addr; 1881 int error = -EAGAIN; 1882 struct ext4_iloc iloc; 1883 1884 down_read(&EXT4_I(inode)->xattr_sem); 1885 if (!ext4_has_inline_data(inode)) 1886 goto out; 1887 1888 error = ext4_get_inode_loc(inode, &iloc); 1889 if (error) 1890 goto out; 1891 1892 addr = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits; 1893 addr += (char *)ext4_raw_inode(&iloc) - iloc.bh->b_data; 1894 addr += offsetof(struct ext4_inode, i_block); 1895 1896 brelse(iloc.bh); 1897 1898 iomap->addr = addr; 1899 iomap->offset = 0; 1900 iomap->length = min_t(loff_t, ext4_get_inline_size(inode), 1901 i_size_read(inode)); 1902 iomap->type = IOMAP_INLINE; 1903 iomap->flags = 0; 1904 1905 out: 1906 up_read(&EXT4_I(inode)->xattr_sem); 1907 return error; 1908 } 1909 1910 int ext4_inline_data_truncate(struct inode *inode, int *has_inline) 1911 { 1912 handle_t *handle; 1913 int inline_size, value_len, needed_blocks, no_expand, err = 0; 1914 size_t i_size; 1915 void *value = NULL; 1916 struct ext4_xattr_ibody_find is = { 1917 .s = { .not_found = -ENODATA, }, 1918 }; 1919 struct ext4_xattr_info i = { 1920 .name_index = EXT4_XATTR_INDEX_SYSTEM, 1921 .name = EXT4_XATTR_SYSTEM_DATA, 1922 }; 1923 1924 1925 needed_blocks = ext4_writepage_trans_blocks(inode); 1926 handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks); 1927 if (IS_ERR(handle)) 1928 return PTR_ERR(handle); 1929 1930 ext4_write_lock_xattr(inode, &no_expand); 1931 if (!ext4_has_inline_data(inode)) { 1932 ext4_write_unlock_xattr(inode, &no_expand); 1933 *has_inline = 0; 1934 ext4_journal_stop(handle); 1935 return 0; 1936 } 1937 1938 if ((err = ext4_orphan_add(handle, inode)) != 0) 1939 goto out; 1940 1941 if ((err = ext4_get_inode_loc(inode, &is.iloc)) != 0) 1942 goto out; 1943 1944 down_write(&EXT4_I(inode)->i_data_sem); 1945 i_size = inode->i_size; 1946 inline_size = ext4_get_inline_size(inode); 1947 EXT4_I(inode)->i_disksize = i_size; 1948 1949 if (i_size < inline_size) { 1950 /* 1951 * if there's inline data to truncate and this file was 1952 * converted to extents after that inline data was written, 1953 * the extent status cache must be cleared to avoid leaving 1954 * behind stale delayed allocated extent entries 1955 */ 1956 if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { 1957 retry: 1958 err = ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS); 1959 if (err == -ENOMEM) { 1960 memalloc_retry_wait(GFP_ATOMIC); 1961 goto retry; 1962 } 1963 if (err) 1964 goto out_error; 1965 } 1966 1967 /* Clear the content in the xattr space. */ 1968 if (inline_size > EXT4_MIN_INLINE_DATA_SIZE) { 1969 if ((err = ext4_xattr_ibody_find(inode, &i, &is)) != 0) 1970 goto out_error; 1971 1972 BUG_ON(is.s.not_found); 1973 1974 value_len = le32_to_cpu(is.s.here->e_value_size); 1975 value = kmalloc(value_len, GFP_NOFS); 1976 if (!value) { 1977 err = -ENOMEM; 1978 goto out_error; 1979 } 1980 1981 err = ext4_xattr_ibody_get(inode, i.name_index, 1982 i.name, value, value_len); 1983 if (err <= 0) 1984 goto out_error; 1985 1986 i.value = value; 1987 i.value_len = i_size > EXT4_MIN_INLINE_DATA_SIZE ? 1988 i_size - EXT4_MIN_INLINE_DATA_SIZE : 0; 1989 err = ext4_xattr_ibody_set(handle, inode, &i, &is); 1990 if (err) 1991 goto out_error; 1992 } 1993 1994 /* Clear the content within i_blocks. */ 1995 if (i_size < EXT4_MIN_INLINE_DATA_SIZE) { 1996 void *p = (void *) ext4_raw_inode(&is.iloc)->i_block; 1997 memset(p + i_size, 0, 1998 EXT4_MIN_INLINE_DATA_SIZE - i_size); 1999 } 2000 2001 EXT4_I(inode)->i_inline_size = i_size < 2002 EXT4_MIN_INLINE_DATA_SIZE ? 2003 EXT4_MIN_INLINE_DATA_SIZE : i_size; 2004 } 2005 2006 out_error: 2007 up_write(&EXT4_I(inode)->i_data_sem); 2008 out: 2009 brelse(is.iloc.bh); 2010 ext4_write_unlock_xattr(inode, &no_expand); 2011 kfree(value); 2012 if (inode->i_nlink) 2013 ext4_orphan_del(handle, inode); 2014 2015 if (err == 0) { 2016 inode->i_mtime = inode->i_ctime = current_time(inode); 2017 err = ext4_mark_inode_dirty(handle, inode); 2018 if (IS_SYNC(inode)) 2019 ext4_handle_sync(handle); 2020 } 2021 ext4_journal_stop(handle); 2022 return err; 2023 } 2024 2025 int ext4_convert_inline_data(struct inode *inode) 2026 { 2027 int error, needed_blocks, no_expand; 2028 handle_t *handle; 2029 struct ext4_iloc iloc; 2030 2031 if (!ext4_has_inline_data(inode)) { 2032 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 2033 return 0; 2034 } else if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { 2035 /* 2036 * Inode has inline data but EXT4_STATE_MAY_INLINE_DATA is 2037 * cleared. This means we are in the middle of moving of 2038 * inline data to delay allocated block. Just force writeout 2039 * here to finish conversion. 2040 */ 2041 error = filemap_flush(inode->i_mapping); 2042 if (error) 2043 return error; 2044 if (!ext4_has_inline_data(inode)) 2045 return 0; 2046 } 2047 2048 needed_blocks = ext4_writepage_trans_blocks(inode); 2049 2050 iloc.bh = NULL; 2051 error = ext4_get_inode_loc(inode, &iloc); 2052 if (error) 2053 return error; 2054 2055 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 2056 if (IS_ERR(handle)) { 2057 error = PTR_ERR(handle); 2058 goto out_free; 2059 } 2060 2061 ext4_write_lock_xattr(inode, &no_expand); 2062 if (ext4_has_inline_data(inode)) 2063 error = ext4_convert_inline_data_nolock(handle, inode, &iloc); 2064 ext4_write_unlock_xattr(inode, &no_expand); 2065 ext4_journal_stop(handle); 2066 out_free: 2067 brelse(iloc.bh); 2068 return error; 2069 } 2070