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