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