1 // SPDX-License-Identifier: LGPL-2.1
3 * Copyright (c) 2012 Taobao.
4 * Written by Tao Ma <boyu.mt@taobao.com>
7 #include <linux/iomap.h>
8 #include <linux/fiemap.h>
9 #include <linux/iversion.h>
11 #include "ext4_jbd2.h"
16 #define EXT4_XATTR_SYSTEM_DATA "data"
17 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS))
18 #define EXT4_INLINE_DOTDOT_OFFSET 2
19 #define EXT4_INLINE_DOTDOT_SIZE 4
21 static int ext4_get_inline_size(struct inode
*inode
)
23 if (EXT4_I(inode
)->i_inline_off
)
24 return EXT4_I(inode
)->i_inline_size
;
29 static int get_max_inline_xattr_value_size(struct inode
*inode
,
30 struct ext4_iloc
*iloc
)
32 struct ext4_xattr_ibody_header
*header
;
33 struct ext4_xattr_entry
*entry
;
34 struct ext4_inode
*raw_inode
;
37 min_offs
= EXT4_SB(inode
->i_sb
)->s_inode_size
-
38 EXT4_GOOD_OLD_INODE_SIZE
-
39 EXT4_I(inode
)->i_extra_isize
-
40 sizeof(struct ext4_xattr_ibody_header
);
43 * We need to subtract another sizeof(__u32) since an in-inode xattr
44 * needs an empty 4 bytes to indicate the gap between the xattr entry
45 * and the name/value pair.
47 if (!ext4_test_inode_state(inode
, EXT4_STATE_XATTR
))
48 return EXT4_XATTR_SIZE(min_offs
-
49 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
)) -
50 EXT4_XATTR_ROUND
- sizeof(__u32
));
52 raw_inode
= ext4_raw_inode(iloc
);
53 header
= IHDR(inode
, raw_inode
);
54 entry
= IFIRST(header
);
56 /* Compute min_offs. */
57 for (; !IS_LAST_ENTRY(entry
); entry
= EXT4_XATTR_NEXT(entry
)) {
58 if (!entry
->e_value_inum
&& entry
->e_value_size
) {
59 size_t offs
= le16_to_cpu(entry
->e_value_offs
);
65 ((void *)entry
- (void *)IFIRST(header
)) - sizeof(__u32
);
67 if (EXT4_I(inode
)->i_inline_off
) {
68 entry
= (struct ext4_xattr_entry
*)
69 ((void *)raw_inode
+ EXT4_I(inode
)->i_inline_off
);
71 free
+= EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
));
75 free
-= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
));
77 if (free
> EXT4_XATTR_ROUND
)
78 free
= EXT4_XATTR_SIZE(free
- EXT4_XATTR_ROUND
);
87 * Get the maximum size we now can store in an inode.
88 * If we can't find the space for a xattr entry, don't use the space
89 * of the extents since we have no space to indicate the inline data.
91 int ext4_get_max_inline_size(struct inode
*inode
)
93 int error
, max_inline_size
;
94 struct ext4_iloc iloc
;
96 if (EXT4_I(inode
)->i_extra_isize
== 0)
99 error
= ext4_get_inode_loc(inode
, &iloc
);
101 ext4_error_inode_err(inode
, __func__
, __LINE__
, 0, -error
,
102 "can't get inode location %lu",
107 down_read(&EXT4_I(inode
)->xattr_sem
);
108 max_inline_size
= get_max_inline_xattr_value_size(inode
, &iloc
);
109 up_read(&EXT4_I(inode
)->xattr_sem
);
113 if (!max_inline_size
)
116 return max_inline_size
+ EXT4_MIN_INLINE_DATA_SIZE
;
120 * this function does not take xattr_sem, which is OK because it is
121 * currently only used in a code path coming form ext4_iget, before
122 * the new inode has been unlocked
124 int ext4_find_inline_data_nolock(struct inode
*inode
)
126 struct ext4_xattr_ibody_find is
= {
127 .s
= { .not_found
= -ENODATA
, },
129 struct ext4_xattr_info i
= {
130 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
131 .name
= EXT4_XATTR_SYSTEM_DATA
,
135 if (EXT4_I(inode
)->i_extra_isize
== 0)
138 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
142 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
146 if (!is
.s
.not_found
) {
147 if (is
.s
.here
->e_value_inum
) {
148 EXT4_ERROR_INODE(inode
, "inline data xattr refers "
149 "to an external xattr inode");
150 error
= -EFSCORRUPTED
;
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
);
164 static int ext4_read_inline_data(struct inode
*inode
, void *buffer
,
166 struct ext4_iloc
*iloc
)
168 struct ext4_xattr_entry
*entry
;
169 struct ext4_xattr_ibody_header
*header
;
171 struct ext4_inode
*raw_inode
;
176 BUG_ON(len
> EXT4_I(inode
)->i_inline_size
);
178 cp_len
= len
< EXT4_MIN_INLINE_DATA_SIZE
?
179 len
: EXT4_MIN_INLINE_DATA_SIZE
;
181 raw_inode
= ext4_raw_inode(iloc
);
182 memcpy(buffer
, (void *)(raw_inode
->i_block
), cp_len
);
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
));
197 (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
), len
);
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.
210 static void ext4_write_inline_data(struct inode
*inode
, struct ext4_iloc
*iloc
,
211 void *buffer
, loff_t pos
, unsigned int len
)
213 struct ext4_xattr_entry
*entry
;
214 struct ext4_xattr_ibody_header
*header
;
215 struct ext4_inode
*raw_inode
;
218 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
221 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
222 BUG_ON(pos
+ len
> EXT4_I(inode
)->i_inline_size
);
224 raw_inode
= ext4_raw_inode(iloc
);
227 if (pos
< EXT4_MIN_INLINE_DATA_SIZE
) {
228 cp_len
= pos
+ len
> EXT4_MIN_INLINE_DATA_SIZE
?
229 EXT4_MIN_INLINE_DATA_SIZE
- pos
: len
;
230 memcpy((void *)raw_inode
->i_block
+ pos
, buffer
, cp_len
);
240 pos
-= EXT4_MIN_INLINE_DATA_SIZE
;
241 header
= IHDR(inode
, raw_inode
);
242 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
243 EXT4_I(inode
)->i_inline_off
);
245 memcpy((void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
) + pos
,
249 static int ext4_create_inline_data(handle_t
*handle
,
250 struct inode
*inode
, unsigned len
)
254 struct ext4_xattr_ibody_find is
= {
255 .s
= { .not_found
= -ENODATA
, },
257 struct ext4_xattr_info i
= {
258 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
259 .name
= EXT4_XATTR_SYSTEM_DATA
,
262 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
266 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
267 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
271 if (len
> EXT4_MIN_INLINE_DATA_SIZE
) {
272 value
= EXT4_ZERO_XATTR_VALUE
;
273 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
279 /* Insert the xttr entry. */
283 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
287 BUG_ON(!is
.s
.not_found
);
289 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
291 if (error
== -ENOSPC
)
292 ext4_clear_inode_state(inode
,
293 EXT4_STATE_MAY_INLINE_DATA
);
297 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
298 0, EXT4_MIN_INLINE_DATA_SIZE
);
300 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
301 (void *)ext4_raw_inode(&is
.iloc
));
302 EXT4_I(inode
)->i_inline_size
= len
+ EXT4_MIN_INLINE_DATA_SIZE
;
303 ext4_clear_inode_flag(inode
, EXT4_INODE_EXTENTS
);
304 ext4_set_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
306 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
313 static int ext4_update_inline_data(handle_t
*handle
, struct inode
*inode
,
318 struct ext4_xattr_ibody_find is
= {
319 .s
= { .not_found
= -ENODATA
, },
321 struct ext4_xattr_info i
= {
322 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
323 .name
= EXT4_XATTR_SYSTEM_DATA
,
326 /* If the old space is ok, write the data directly. */
327 if (len
<= EXT4_I(inode
)->i_inline_size
)
330 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
334 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
338 BUG_ON(is
.s
.not_found
);
340 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
341 value
= kzalloc(len
, GFP_NOFS
);
347 error
= ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
349 if (error
== -ENODATA
)
352 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
353 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
357 /* Update the xattr entry. */
361 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
365 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
366 (void *)ext4_raw_inode(&is
.iloc
));
367 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
368 le32_to_cpu(is
.s
.here
->e_value_size
);
369 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
371 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
379 static int ext4_prepare_inline_data(handle_t
*handle
, struct inode
*inode
,
382 int ret
, size
, no_expand
;
383 struct ext4_inode_info
*ei
= EXT4_I(inode
);
385 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
))
388 size
= ext4_get_max_inline_size(inode
);
392 ext4_write_lock_xattr(inode
, &no_expand
);
394 if (ei
->i_inline_off
)
395 ret
= ext4_update_inline_data(handle
, inode
, len
);
397 ret
= ext4_create_inline_data(handle
, inode
, len
);
399 ext4_write_unlock_xattr(inode
, &no_expand
);
403 static int ext4_destroy_inline_data_nolock(handle_t
*handle
,
406 struct ext4_inode_info
*ei
= EXT4_I(inode
);
407 struct ext4_xattr_ibody_find is
= {
408 .s
= { .not_found
= 0, },
410 struct ext4_xattr_info i
= {
411 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
412 .name
= EXT4_XATTR_SYSTEM_DATA
,
418 if (!ei
->i_inline_off
)
421 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
425 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
429 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
430 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
434 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
438 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
439 0, EXT4_MIN_INLINE_DATA_SIZE
);
440 memset(ei
->i_data
, 0, EXT4_MIN_INLINE_DATA_SIZE
);
442 if (ext4_has_feature_extents(inode
->i_sb
)) {
443 if (S_ISDIR(inode
->i_mode
) ||
444 S_ISREG(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) {
445 ext4_set_inode_flag(inode
, EXT4_INODE_EXTENTS
);
446 ext4_ext_tree_init(handle
, inode
);
449 ext4_clear_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
452 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
454 EXT4_I(inode
)->i_inline_off
= 0;
455 EXT4_I(inode
)->i_inline_size
= 0;
456 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
459 if (error
== -ENODATA
)
464 static int ext4_read_inline_page(struct inode
*inode
, struct page
*page
)
469 struct ext4_iloc iloc
;
471 BUG_ON(!PageLocked(page
));
472 BUG_ON(!ext4_has_inline_data(inode
));
475 if (!EXT4_I(inode
)->i_inline_off
) {
476 ext4_warning(inode
->i_sb
, "inode %lu doesn't have inline data.",
481 ret
= ext4_get_inode_loc(inode
, &iloc
);
485 len
= min_t(size_t, ext4_get_inline_size(inode
), i_size_read(inode
));
486 kaddr
= kmap_atomic(page
);
487 ret
= ext4_read_inline_data(inode
, kaddr
, len
, &iloc
);
488 flush_dcache_page(page
);
489 kunmap_atomic(kaddr
);
490 zero_user_segment(page
, len
, PAGE_SIZE
);
491 SetPageUptodate(page
);
498 int ext4_readpage_inline(struct inode
*inode
, struct page
*page
)
502 down_read(&EXT4_I(inode
)->xattr_sem
);
503 if (!ext4_has_inline_data(inode
)) {
504 up_read(&EXT4_I(inode
)->xattr_sem
);
509 * Current inline data can only exist in the 1st page,
510 * So for all the other pages, just set them uptodate.
513 ret
= ext4_read_inline_page(inode
, page
);
514 else if (!PageUptodate(page
)) {
515 zero_user_segment(page
, 0, PAGE_SIZE
);
516 SetPageUptodate(page
);
519 up_read(&EXT4_I(inode
)->xattr_sem
);
522 return ret
>= 0 ? 0 : ret
;
525 static int ext4_convert_inline_data_to_extent(struct address_space
*mapping
,
529 int ret
, needed_blocks
, no_expand
;
530 handle_t
*handle
= NULL
;
531 int retries
= 0, sem_held
= 0;
532 struct page
*page
= NULL
;
534 struct ext4_iloc iloc
;
536 if (!ext4_has_inline_data(inode
)) {
538 * clear the flag so that no new write
539 * will trap here again.
541 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
545 needed_blocks
= ext4_writepage_trans_blocks(inode
);
547 ret
= ext4_get_inode_loc(inode
, &iloc
);
552 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
553 if (IS_ERR(handle
)) {
554 ret
= PTR_ERR(handle
);
559 /* We cannot recurse into the filesystem as the transaction is already
561 flags
|= AOP_FLAG_NOFS
;
563 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
569 ext4_write_lock_xattr(inode
, &no_expand
);
571 /* If some one has already done this for us, just exit. */
572 if (!ext4_has_inline_data(inode
)) {
578 to
= ext4_get_inline_size(inode
);
579 if (!PageUptodate(page
)) {
580 ret
= ext4_read_inline_page(inode
, page
);
585 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
589 if (ext4_should_dioread_nolock(inode
)) {
590 ret
= __block_write_begin(page
, from
, to
,
591 ext4_get_block_unwritten
);
593 ret
= __block_write_begin(page
, from
, to
, ext4_get_block
);
595 if (!ret
&& ext4_should_journal_data(inode
)) {
596 ret
= ext4_walk_page_buffers(handle
, page_buffers(page
),
598 do_journal_get_write_access
);
605 ext4_orphan_add(handle
, inode
);
606 ext4_write_unlock_xattr(inode
, &no_expand
);
608 ext4_journal_stop(handle
);
610 ext4_truncate_failed_write(inode
);
612 * If truncate failed early the inode might
613 * still be on the orphan list; we need to
614 * make sure the inode is removed from the
615 * orphan list in that case.
618 ext4_orphan_del(NULL
, inode
);
621 if (ret
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
625 block_commit_write(page
, from
, to
);
632 ext4_write_unlock_xattr(inode
, &no_expand
);
634 ext4_journal_stop(handle
);
640 * Try to write data in the inode.
641 * If the inode has inline data, check whether the new write can be
642 * in the inode also. If not, create the page the handle, move the data
643 * to the page make it update and let the later codes create extent for it.
645 int ext4_try_to_write_inline_data(struct address_space
*mapping
,
647 loff_t pos
, unsigned len
,
654 struct ext4_iloc iloc
;
656 if (pos
+ len
> ext4_get_max_inline_size(inode
))
659 ret
= ext4_get_inode_loc(inode
, &iloc
);
664 * The possible write could happen in the inode,
665 * so try to reserve the space in inode first.
667 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
668 if (IS_ERR(handle
)) {
669 ret
= PTR_ERR(handle
);
674 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
675 if (ret
&& ret
!= -ENOSPC
)
678 /* We don't have space in inline inode, so convert it to extent. */
679 if (ret
== -ENOSPC
) {
680 ext4_journal_stop(handle
);
685 ret
= ext4_journal_get_write_access(handle
, iloc
.bh
);
689 flags
|= AOP_FLAG_NOFS
;
691 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
698 down_read(&EXT4_I(inode
)->xattr_sem
);
699 if (!ext4_has_inline_data(inode
)) {
706 if (!PageUptodate(page
)) {
707 ret
= ext4_read_inline_page(inode
, page
);
718 up_read(&EXT4_I(inode
)->xattr_sem
);
720 if (handle
&& (ret
!= 1))
721 ext4_journal_stop(handle
);
725 return ext4_convert_inline_data_to_extent(mapping
,
729 int ext4_write_inline_data_end(struct inode
*inode
, loff_t pos
, unsigned len
,
730 unsigned copied
, struct page
*page
)
734 struct ext4_iloc iloc
;
736 if (unlikely(copied
< len
)) {
737 if (!PageUptodate(page
)) {
743 ret
= ext4_get_inode_loc(inode
, &iloc
);
745 ext4_std_error(inode
->i_sb
, ret
);
750 ext4_write_lock_xattr(inode
, &no_expand
);
751 BUG_ON(!ext4_has_inline_data(inode
));
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
);
760 ext4_write_unlock_xattr(inode
, &no_expand
);
762 mark_inode_dirty(inode
);
768 ext4_journalled_write_inline_data(struct inode
*inode
,
774 struct ext4_iloc iloc
;
776 ret
= ext4_get_inode_loc(inode
, &iloc
);
778 ext4_std_error(inode
->i_sb
, ret
);
782 ext4_write_lock_xattr(inode
, &no_expand
);
783 kaddr
= kmap_atomic(page
);
784 ext4_write_inline_data(inode
, &iloc
, kaddr
, 0, len
);
785 kunmap_atomic(kaddr
);
786 ext4_write_unlock_xattr(inode
, &no_expand
);
792 * Try to make the page cache and handle ready for the inline data case.
793 * We can call this function in 2 cases:
794 * 1. The inode is created and the first write exceeds inline size. We can
795 * clear the inode state safely.
796 * 2. The inode has inline data, then we need to read the data, make it
797 * update and dirty so that ext4_da_writepages can handle it. We don't
798 * need to start the journal since the file's metatdata isn't changed now.
800 static int ext4_da_convert_inline_data_to_extent(struct address_space
*mapping
,
805 int ret
= 0, inline_size
;
808 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
812 down_read(&EXT4_I(inode
)->xattr_sem
);
813 if (!ext4_has_inline_data(inode
)) {
814 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
818 inline_size
= ext4_get_inline_size(inode
);
820 if (!PageUptodate(page
)) {
821 ret
= ext4_read_inline_page(inode
, page
);
826 ret
= __block_write_begin(page
, 0, inline_size
,
827 ext4_da_get_block_prep
);
829 up_read(&EXT4_I(inode
)->xattr_sem
);
832 ext4_truncate_failed_write(inode
);
837 SetPageUptodate(page
);
838 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
839 *fsdata
= (void *)CONVERT_INLINE_DATA
;
842 up_read(&EXT4_I(inode
)->xattr_sem
);
851 * Prepare the write for the inline data.
852 * If the data can be written into the inode, we just read
853 * the page and make it uptodate, and start the journal.
854 * Otherwise read the page, makes it dirty so that it can be
855 * handle in writepages(the i_disksize update is left to the
856 * normal ext4_da_write_end).
858 int ext4_da_write_inline_data_begin(struct address_space
*mapping
,
860 loff_t pos
, unsigned len
,
865 int ret
, inline_size
;
868 struct ext4_iloc iloc
;
871 ret
= ext4_get_inode_loc(inode
, &iloc
);
876 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
877 if (IS_ERR(handle
)) {
878 ret
= PTR_ERR(handle
);
882 inline_size
= ext4_get_max_inline_size(inode
);
885 if (inline_size
>= pos
+ len
) {
886 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
887 if (ret
&& ret
!= -ENOSPC
)
892 * We cannot recurse into the filesystem as the transaction
893 * is already started.
895 flags
|= AOP_FLAG_NOFS
;
897 if (ret
== -ENOSPC
) {
898 ext4_journal_stop(handle
);
899 ret
= ext4_da_convert_inline_data_to_extent(mapping
,
903 if (ret
== -ENOSPC
&&
904 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
909 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
915 down_read(&EXT4_I(inode
)->xattr_sem
);
916 if (!ext4_has_inline_data(inode
)) {
918 goto out_release_page
;
921 if (!PageUptodate(page
)) {
922 ret
= ext4_read_inline_page(inode
, page
);
924 goto out_release_page
;
926 ret
= ext4_journal_get_write_access(handle
, iloc
.bh
);
928 goto out_release_page
;
930 up_read(&EXT4_I(inode
)->xattr_sem
);
935 up_read(&EXT4_I(inode
)->xattr_sem
);
939 ext4_journal_stop(handle
);
945 int ext4_da_write_inline_data_end(struct inode
*inode
, loff_t pos
,
946 unsigned len
, unsigned copied
,
951 ret
= ext4_write_inline_data_end(inode
, pos
, len
, copied
, page
);
960 * No need to use i_size_read() here, the i_size
961 * cannot change under us because we hold i_mutex.
963 * But it's important to update i_size while still holding page lock:
964 * page writeout could otherwise come in and zero beyond i_size.
966 if (pos
+copied
> inode
->i_size
)
967 i_size_write(inode
, pos
+copied
);
972 * Don't mark the inode dirty under page lock. First, it unnecessarily
973 * makes the holding time of page lock longer. Second, it forces lock
974 * ordering of page lock and transaction start for journaling
977 mark_inode_dirty(inode
);
982 #ifdef INLINE_DIR_DEBUG
983 void ext4_show_inline_dir(struct inode
*dir
, struct buffer_head
*bh
,
984 void *inline_start
, int inline_size
)
987 unsigned short de_len
;
988 struct ext4_dir_entry_2
*de
= inline_start
;
989 void *dlimit
= inline_start
+ inline_size
;
991 trace_printk("inode %lu\n", dir
->i_ino
);
993 while ((void *)de
< dlimit
) {
994 de_len
= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
995 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
996 offset
, de_len
, de
->name_len
, de
->name
,
997 de
->name_len
, le32_to_cpu(de
->inode
));
998 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
999 inline_start
, inline_size
, offset
))
1003 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
1007 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
1011 * Add a new entry into a inline dir.
1012 * It will return -ENOSPC if no space is available, and -EIO
1013 * and -EEXIST if directory entry already exists.
1015 static int ext4_add_dirent_to_inline(handle_t
*handle
,
1016 struct ext4_filename
*fname
,
1018 struct inode
*inode
,
1019 struct ext4_iloc
*iloc
,
1020 void *inline_start
, int inline_size
)
1023 struct ext4_dir_entry_2
*de
;
1025 err
= ext4_find_dest_de(dir
, inode
, iloc
->bh
, inline_start
,
1026 inline_size
, fname
, &de
);
1030 BUFFER_TRACE(iloc
->bh
, "get_write_access");
1031 err
= ext4_journal_get_write_access(handle
, iloc
->bh
);
1034 ext4_insert_dentry(inode
, de
, inline_size
, fname
);
1036 ext4_show_inline_dir(dir
, iloc
->bh
, inline_start
, inline_size
);
1039 * XXX shouldn't update any times until successful
1040 * completion of syscall, but too many callers depend
1043 * XXX similarly, too many callers depend on
1044 * ext4_new_inode() setting the times, but error
1045 * recovery deletes the inode, so the worst that can
1046 * happen is that the times are slightly out of date
1047 * and/or different from the directory change time.
1049 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1050 ext4_update_dx_flag(dir
);
1051 inode_inc_iversion(dir
);
1055 static void *ext4_get_inline_xattr_pos(struct inode
*inode
,
1056 struct ext4_iloc
*iloc
)
1058 struct ext4_xattr_entry
*entry
;
1059 struct ext4_xattr_ibody_header
*header
;
1061 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
1063 header
= IHDR(inode
, ext4_raw_inode(iloc
));
1064 entry
= (struct ext4_xattr_entry
*)((void *)ext4_raw_inode(iloc
) +
1065 EXT4_I(inode
)->i_inline_off
);
1067 return (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
);
1070 /* Set the final de to cover the whole block. */
1071 static void ext4_update_final_de(void *de_buf
, int old_size
, int new_size
)
1073 struct ext4_dir_entry_2
*de
, *prev_de
;
1077 de
= (struct ext4_dir_entry_2
*)de_buf
;
1079 limit
= de_buf
+ old_size
;
1082 de_len
= ext4_rec_len_from_disk(de
->rec_len
, old_size
);
1084 de
= (struct ext4_dir_entry_2
*)de_buf
;
1085 } while (de_buf
< limit
);
1087 prev_de
->rec_len
= ext4_rec_len_to_disk(de_len
+ new_size
-
1088 old_size
, new_size
);
1090 /* this is just created, so create an empty entry. */
1092 de
->rec_len
= ext4_rec_len_to_disk(new_size
, new_size
);
1096 static int ext4_update_inline_dir(handle_t
*handle
, struct inode
*dir
,
1097 struct ext4_iloc
*iloc
)
1100 int old_size
= EXT4_I(dir
)->i_inline_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1101 int new_size
= get_max_inline_xattr_value_size(dir
, iloc
);
1103 if (new_size
- old_size
<= EXT4_DIR_REC_LEN(1))
1106 ret
= ext4_update_inline_data(handle
, dir
,
1107 new_size
+ EXT4_MIN_INLINE_DATA_SIZE
);
1111 ext4_update_final_de(ext4_get_inline_xattr_pos(dir
, iloc
), old_size
,
1112 EXT4_I(dir
)->i_inline_size
-
1113 EXT4_MIN_INLINE_DATA_SIZE
);
1114 dir
->i_size
= EXT4_I(dir
)->i_disksize
= EXT4_I(dir
)->i_inline_size
;
1118 static void ext4_restore_inline_data(handle_t
*handle
, struct inode
*inode
,
1119 struct ext4_iloc
*iloc
,
1120 void *buf
, int inline_size
)
1122 ext4_create_inline_data(handle
, inode
, inline_size
);
1123 ext4_write_inline_data(inode
, iloc
, buf
, 0, inline_size
);
1124 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1127 static int ext4_finish_convert_inline_dir(handle_t
*handle
,
1128 struct inode
*inode
,
1129 struct buffer_head
*dir_block
,
1133 int err
, csum_size
= 0, header_size
= 0;
1134 struct ext4_dir_entry_2
*de
;
1135 void *target
= dir_block
->b_data
;
1138 * First create "." and ".." and then copy the dir information
1139 * back to the block.
1141 de
= (struct ext4_dir_entry_2
*)target
;
1142 de
= ext4_init_dot_dotdot(inode
, de
,
1143 inode
->i_sb
->s_blocksize
, csum_size
,
1144 le32_to_cpu(((struct ext4_dir_entry_2
*)buf
)->inode
), 1);
1145 header_size
= (void *)de
- target
;
1147 memcpy((void *)de
, buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1148 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1150 if (ext4_has_metadata_csum(inode
->i_sb
))
1151 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1153 inode
->i_size
= inode
->i_sb
->s_blocksize
;
1154 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
1155 EXT4_I(inode
)->i_disksize
= inode
->i_sb
->s_blocksize
;
1156 ext4_update_final_de(dir_block
->b_data
,
1157 inline_size
- EXT4_INLINE_DOTDOT_SIZE
+ header_size
,
1158 inode
->i_sb
->s_blocksize
- csum_size
);
1161 ext4_initialize_dirent_tail(dir_block
,
1162 inode
->i_sb
->s_blocksize
);
1163 set_buffer_uptodate(dir_block
);
1164 err
= ext4_handle_dirty_dirblock(handle
, inode
, dir_block
);
1167 set_buffer_verified(dir_block
);
1168 return ext4_mark_inode_dirty(handle
, inode
);
1171 static int ext4_convert_inline_data_nolock(handle_t
*handle
,
1172 struct inode
*inode
,
1173 struct ext4_iloc
*iloc
)
1177 struct buffer_head
*data_bh
= NULL
;
1178 struct ext4_map_blocks map
;
1181 inline_size
= ext4_get_inline_size(inode
);
1182 buf
= kmalloc(inline_size
, GFP_NOFS
);
1188 error
= ext4_read_inline_data(inode
, buf
, inline_size
, iloc
);
1193 * Make sure the inline directory entries pass checks before we try to
1194 * convert them, so that we avoid touching stuff that needs fsck.
1196 if (S_ISDIR(inode
->i_mode
)) {
1197 error
= ext4_check_all_de(inode
, iloc
->bh
,
1198 buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1199 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1204 error
= ext4_destroy_inline_data_nolock(handle
, inode
);
1211 error
= ext4_map_blocks(handle
, inode
, &map
, EXT4_GET_BLOCKS_CREATE
);
1214 if (!(map
.m_flags
& EXT4_MAP_MAPPED
)) {
1219 data_bh
= sb_getblk(inode
->i_sb
, map
.m_pblk
);
1225 lock_buffer(data_bh
);
1226 error
= ext4_journal_get_create_access(handle
, data_bh
);
1228 unlock_buffer(data_bh
);
1232 memset(data_bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1234 if (!S_ISDIR(inode
->i_mode
)) {
1235 memcpy(data_bh
->b_data
, buf
, inline_size
);
1236 set_buffer_uptodate(data_bh
);
1237 error
= ext4_handle_dirty_metadata(handle
,
1240 error
= ext4_finish_convert_inline_dir(handle
, inode
, data_bh
,
1244 unlock_buffer(data_bh
);
1247 ext4_restore_inline_data(handle
, inode
, iloc
, buf
, inline_size
);
1256 * Try to add the new entry to the inline data.
1257 * If succeeds, return 0. If not, extended the inline dir and copied data to
1258 * the new created block.
1260 int ext4_try_add_inline_entry(handle_t
*handle
, struct ext4_filename
*fname
,
1261 struct inode
*dir
, struct inode
*inode
)
1263 int ret
, ret2
, inline_size
, no_expand
;
1265 struct ext4_iloc iloc
;
1267 ret
= ext4_get_inode_loc(dir
, &iloc
);
1271 ext4_write_lock_xattr(dir
, &no_expand
);
1272 if (!ext4_has_inline_data(dir
))
1275 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1276 EXT4_INLINE_DOTDOT_SIZE
;
1277 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1279 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
, inode
, &iloc
,
1280 inline_start
, inline_size
);
1284 /* check whether it can be inserted to inline xattr space. */
1285 inline_size
= EXT4_I(dir
)->i_inline_size
-
1286 EXT4_MIN_INLINE_DATA_SIZE
;
1288 /* Try to use the xattr space.*/
1289 ret
= ext4_update_inline_dir(handle
, dir
, &iloc
);
1290 if (ret
&& ret
!= -ENOSPC
)
1293 inline_size
= EXT4_I(dir
)->i_inline_size
-
1294 EXT4_MIN_INLINE_DATA_SIZE
;
1298 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1300 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
,
1301 inode
, &iloc
, inline_start
,
1309 * The inline space is filled up, so create a new block for it.
1310 * As the extent tree will be created, we have to save the inline
1313 ret
= ext4_convert_inline_data_nolock(handle
, dir
, &iloc
);
1316 ext4_write_unlock_xattr(dir
, &no_expand
);
1317 ret2
= ext4_mark_inode_dirty(handle
, dir
);
1318 if (unlikely(ret2
&& !ret
))
1325 * This function fills a red-black tree with information from an
1326 * inlined dir. It returns the number directory entries loaded
1327 * into the tree. If there is an error it is returned in err.
1329 int ext4_inlinedir_to_tree(struct file
*dir_file
,
1330 struct inode
*dir
, ext4_lblk_t block
,
1331 struct dx_hash_info
*hinfo
,
1332 __u32 start_hash
, __u32 start_minor_hash
,
1333 int *has_inline_data
)
1335 int err
= 0, count
= 0;
1336 unsigned int parent_ino
;
1338 struct ext4_dir_entry_2
*de
;
1339 struct inode
*inode
= file_inode(dir_file
);
1340 int ret
, inline_size
= 0;
1341 struct ext4_iloc iloc
;
1342 void *dir_buf
= NULL
;
1343 struct ext4_dir_entry_2 fake
;
1344 struct fscrypt_str tmp_str
;
1346 ret
= ext4_get_inode_loc(inode
, &iloc
);
1350 down_read(&EXT4_I(inode
)->xattr_sem
);
1351 if (!ext4_has_inline_data(inode
)) {
1352 up_read(&EXT4_I(inode
)->xattr_sem
);
1353 *has_inline_data
= 0;
1357 inline_size
= ext4_get_inline_size(inode
);
1358 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1361 up_read(&EXT4_I(inode
)->xattr_sem
);
1365 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1366 up_read(&EXT4_I(inode
)->xattr_sem
);
1371 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1372 while (pos
< inline_size
) {
1374 * As inlined dir doesn't store any information about '.' and
1375 * only the inode number of '..' is stored, we have to handle
1379 fake
.inode
= cpu_to_le32(inode
->i_ino
);
1381 strcpy(fake
.name
, ".");
1382 fake
.rec_len
= ext4_rec_len_to_disk(
1383 EXT4_DIR_REC_LEN(fake
.name_len
),
1385 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1387 pos
= EXT4_INLINE_DOTDOT_OFFSET
;
1388 } else if (pos
== EXT4_INLINE_DOTDOT_OFFSET
) {
1389 fake
.inode
= cpu_to_le32(parent_ino
);
1391 strcpy(fake
.name
, "..");
1392 fake
.rec_len
= ext4_rec_len_to_disk(
1393 EXT4_DIR_REC_LEN(fake
.name_len
),
1395 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1397 pos
= EXT4_INLINE_DOTDOT_SIZE
;
1399 de
= (struct ext4_dir_entry_2
*)(dir_buf
+ pos
);
1400 pos
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1401 if (ext4_check_dir_entry(inode
, dir_file
, de
,
1403 inline_size
, pos
)) {
1409 ext4fs_dirhash(dir
, de
->name
, de
->name_len
, hinfo
);
1410 if ((hinfo
->hash
< start_hash
) ||
1411 ((hinfo
->hash
== start_hash
) &&
1412 (hinfo
->minor_hash
< start_minor_hash
)))
1416 tmp_str
.name
= de
->name
;
1417 tmp_str
.len
= de
->name_len
;
1418 err
= ext4_htree_store_dirent(dir_file
, hinfo
->hash
,
1419 hinfo
->minor_hash
, de
, &tmp_str
);
1434 * So this function is called when the volume is mkfsed with
1435 * dir_index disabled. In order to keep f_pos persistent
1436 * after we convert from an inlined dir to a blocked based,
1437 * we just pretend that we are a normal dir and return the
1438 * offset as if '.' and '..' really take place.
1441 int ext4_read_inline_dir(struct file
*file
,
1442 struct dir_context
*ctx
,
1443 int *has_inline_data
)
1445 unsigned int offset
, parent_ino
;
1447 struct ext4_dir_entry_2
*de
;
1448 struct super_block
*sb
;
1449 struct inode
*inode
= file_inode(file
);
1450 int ret
, inline_size
= 0;
1451 struct ext4_iloc iloc
;
1452 void *dir_buf
= NULL
;
1453 int dotdot_offset
, dotdot_size
, extra_offset
, extra_size
;
1455 ret
= ext4_get_inode_loc(inode
, &iloc
);
1459 down_read(&EXT4_I(inode
)->xattr_sem
);
1460 if (!ext4_has_inline_data(inode
)) {
1461 up_read(&EXT4_I(inode
)->xattr_sem
);
1462 *has_inline_data
= 0;
1466 inline_size
= ext4_get_inline_size(inode
);
1467 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1470 up_read(&EXT4_I(inode
)->xattr_sem
);
1474 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1475 up_read(&EXT4_I(inode
)->xattr_sem
);
1481 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1485 * dotdot_offset and dotdot_size is the real offset and
1486 * size for ".." and "." if the dir is block based while
1487 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1488 * So we will use extra_offset and extra_size to indicate them
1489 * during the inline dir iteration.
1491 dotdot_offset
= EXT4_DIR_REC_LEN(1);
1492 dotdot_size
= dotdot_offset
+ EXT4_DIR_REC_LEN(2);
1493 extra_offset
= dotdot_size
- EXT4_INLINE_DOTDOT_SIZE
;
1494 extra_size
= extra_offset
+ inline_size
;
1497 * If the version has changed since the last call to
1498 * readdir(2), then we might be pointing to an invalid
1499 * dirent right now. Scan from the start of the inline
1502 if (!inode_eq_iversion(inode
, file
->f_version
)) {
1503 for (i
= 0; i
< extra_size
&& i
< offset
;) {
1505 * "." is with offset 0 and
1506 * ".." is dotdot_offset.
1511 } else if (i
== dotdot_offset
) {
1515 /* for other entry, the real offset in
1516 * the buf has to be tuned accordingly.
1518 de
= (struct ext4_dir_entry_2
*)
1519 (dir_buf
+ i
- extra_offset
);
1520 /* It's too expensive to do a full
1521 * dirent test each time round this
1522 * loop, but we do have to test at
1523 * least that it is non-zero. A
1524 * failure will be detected in the
1525 * dirent test below. */
1526 if (ext4_rec_len_from_disk(de
->rec_len
, extra_size
)
1527 < EXT4_DIR_REC_LEN(1))
1529 i
+= ext4_rec_len_from_disk(de
->rec_len
,
1534 file
->f_version
= inode_query_iversion(inode
);
1537 while (ctx
->pos
< extra_size
) {
1538 if (ctx
->pos
== 0) {
1539 if (!dir_emit(ctx
, ".", 1, inode
->i_ino
, DT_DIR
))
1541 ctx
->pos
= dotdot_offset
;
1545 if (ctx
->pos
== dotdot_offset
) {
1546 if (!dir_emit(ctx
, "..", 2, parent_ino
, DT_DIR
))
1548 ctx
->pos
= dotdot_size
;
1552 de
= (struct ext4_dir_entry_2
*)
1553 (dir_buf
+ ctx
->pos
- extra_offset
);
1554 if (ext4_check_dir_entry(inode
, file
, de
, iloc
.bh
, dir_buf
,
1555 extra_size
, ctx
->pos
))
1557 if (le32_to_cpu(de
->inode
)) {
1558 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1559 le32_to_cpu(de
->inode
),
1560 get_dtype(sb
, de
->file_type
)))
1563 ctx
->pos
+= ext4_rec_len_from_disk(de
->rec_len
, extra_size
);
1571 struct buffer_head
*ext4_get_first_inline_block(struct inode
*inode
,
1572 struct ext4_dir_entry_2
**parent_de
,
1575 struct ext4_iloc iloc
;
1577 *retval
= ext4_get_inode_loc(inode
, &iloc
);
1581 *parent_de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1587 * Try to create the inline data for the new dir.
1588 * If it succeeds, return 0, otherwise return the error.
1589 * In case of ENOSPC, the caller should create the normal disk layout dir.
1591 int ext4_try_create_inline_dir(handle_t
*handle
, struct inode
*parent
,
1592 struct inode
*inode
)
1594 int ret
, inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1595 struct ext4_iloc iloc
;
1596 struct ext4_dir_entry_2
*de
;
1598 ret
= ext4_get_inode_loc(inode
, &iloc
);
1602 ret
= ext4_prepare_inline_data(handle
, inode
, inline_size
);
1607 * For inline dir, we only save the inode information for the ".."
1608 * and create a fake dentry to cover the left space.
1610 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1611 de
->inode
= cpu_to_le32(parent
->i_ino
);
1612 de
= (struct ext4_dir_entry_2
*)((void *)de
+ EXT4_INLINE_DOTDOT_SIZE
);
1614 de
->rec_len
= ext4_rec_len_to_disk(
1615 inline_size
- EXT4_INLINE_DOTDOT_SIZE
,
1617 set_nlink(inode
, 2);
1618 inode
->i_size
= EXT4_I(inode
)->i_disksize
= inline_size
;
1624 struct buffer_head
*ext4_find_inline_entry(struct inode
*dir
,
1625 struct ext4_filename
*fname
,
1626 struct ext4_dir_entry_2
**res_dir
,
1627 int *has_inline_data
)
1630 struct ext4_iloc iloc
;
1634 if (ext4_get_inode_loc(dir
, &iloc
))
1637 down_read(&EXT4_I(dir
)->xattr_sem
);
1638 if (!ext4_has_inline_data(dir
)) {
1639 *has_inline_data
= 0;
1643 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1644 EXT4_INLINE_DOTDOT_SIZE
;
1645 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1646 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1647 dir
, fname
, 0, res_dir
);
1653 if (ext4_get_inline_size(dir
) == EXT4_MIN_INLINE_DATA_SIZE
)
1656 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1657 inline_size
= ext4_get_inline_size(dir
) - EXT4_MIN_INLINE_DATA_SIZE
;
1659 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1660 dir
, fname
, 0, res_dir
);
1668 up_read(&EXT4_I(dir
)->xattr_sem
);
1672 int ext4_delete_inline_entry(handle_t
*handle
,
1674 struct ext4_dir_entry_2
*de_del
,
1675 struct buffer_head
*bh
,
1676 int *has_inline_data
)
1678 int err
, inline_size
, no_expand
;
1679 struct ext4_iloc iloc
;
1682 err
= ext4_get_inode_loc(dir
, &iloc
);
1686 ext4_write_lock_xattr(dir
, &no_expand
);
1687 if (!ext4_has_inline_data(dir
)) {
1688 *has_inline_data
= 0;
1692 if ((void *)de_del
- ((void *)ext4_raw_inode(&iloc
)->i_block
) <
1693 EXT4_MIN_INLINE_DATA_SIZE
) {
1694 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1695 EXT4_INLINE_DOTDOT_SIZE
;
1696 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
-
1697 EXT4_INLINE_DOTDOT_SIZE
;
1699 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1700 inline_size
= ext4_get_inline_size(dir
) -
1701 EXT4_MIN_INLINE_DATA_SIZE
;
1704 BUFFER_TRACE(bh
, "get_write_access");
1705 err
= ext4_journal_get_write_access(handle
, bh
);
1709 err
= ext4_generic_delete_entry(dir
, de_del
, bh
,
1710 inline_start
, inline_size
, 0);
1714 ext4_show_inline_dir(dir
, iloc
.bh
, inline_start
, inline_size
);
1716 ext4_write_unlock_xattr(dir
, &no_expand
);
1717 if (likely(err
== 0))
1718 err
= ext4_mark_inode_dirty(handle
, dir
);
1721 ext4_std_error(dir
->i_sb
, err
);
1726 * Get the inline dentry at offset.
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
,
1737 BUG_ON(offset
> ext4_get_inline_size(inode
));
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
;
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
;
1750 *inline_start
= inline_pos
;
1751 return (struct ext4_dir_entry_2
*)(inline_pos
+ offset
);
1754 bool empty_inline_dir(struct inode
*dir
, int *has_inline_data
)
1756 int err
, inline_size
;
1757 struct ext4_iloc iloc
;
1760 unsigned int offset
;
1761 struct ext4_dir_entry_2
*de
;
1764 err
= ext4_get_inode_loc(dir
, &iloc
);
1766 EXT4_ERROR_INODE_ERR(dir
, -err
,
1767 "error %d getting inode %lu block",
1772 down_read(&EXT4_I(dir
)->xattr_sem
);
1773 if (!ext4_has_inline_data(dir
)) {
1774 *has_inline_data
= 0;
1778 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1779 if (!le32_to_cpu(de
->inode
)) {
1780 ext4_warning(dir
->i_sb
,
1781 "bad inline directory (dir #%lu) - no `..'",
1787 inline_len
= ext4_get_inline_size(dir
);
1788 offset
= EXT4_INLINE_DOTDOT_SIZE
;
1789 while (offset
< inline_len
) {
1790 de
= ext4_get_inline_entry(dir
, &iloc
, offset
,
1791 &inline_pos
, &inline_size
);
1792 if (ext4_check_dir_entry(dir
, NULL
, de
,
1793 iloc
.bh
, inline_pos
,
1794 inline_size
, offset
)) {
1795 ext4_warning(dir
->i_sb
,
1796 "bad inline directory (dir #%lu) - "
1797 "inode %u, rec_len %u, name_len %d"
1799 dir
->i_ino
, le32_to_cpu(de
->inode
),
1800 le16_to_cpu(de
->rec_len
), de
->name_len
,
1805 if (le32_to_cpu(de
->inode
)) {
1809 offset
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1813 up_read(&EXT4_I(dir
)->xattr_sem
);
1818 int ext4_destroy_inline_data(handle_t
*handle
, struct inode
*inode
)
1822 ext4_write_lock_xattr(inode
, &no_expand
);
1823 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
1824 ext4_write_unlock_xattr(inode
, &no_expand
);
1829 int ext4_inline_data_iomap(struct inode
*inode
, struct iomap
*iomap
)
1832 int error
= -EAGAIN
;
1833 struct ext4_iloc iloc
;
1835 down_read(&EXT4_I(inode
)->xattr_sem
);
1836 if (!ext4_has_inline_data(inode
))
1839 error
= ext4_get_inode_loc(inode
, &iloc
);
1843 addr
= (__u64
)iloc
.bh
->b_blocknr
<< inode
->i_sb
->s_blocksize_bits
;
1844 addr
+= (char *)ext4_raw_inode(&iloc
) - iloc
.bh
->b_data
;
1845 addr
+= offsetof(struct ext4_inode
, i_block
);
1851 iomap
->length
= min_t(loff_t
, ext4_get_inline_size(inode
),
1852 i_size_read(inode
));
1853 iomap
->type
= IOMAP_INLINE
;
1857 up_read(&EXT4_I(inode
)->xattr_sem
);
1861 int ext4_inline_data_truncate(struct inode
*inode
, int *has_inline
)
1864 int inline_size
, value_len
, needed_blocks
, no_expand
, err
= 0;
1867 struct ext4_xattr_ibody_find is
= {
1868 .s
= { .not_found
= -ENODATA
, },
1870 struct ext4_xattr_info i
= {
1871 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
1872 .name
= EXT4_XATTR_SYSTEM_DATA
,
1876 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1877 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, needed_blocks
);
1879 return PTR_ERR(handle
);
1881 ext4_write_lock_xattr(inode
, &no_expand
);
1882 if (!ext4_has_inline_data(inode
)) {
1883 ext4_write_unlock_xattr(inode
, &no_expand
);
1885 ext4_journal_stop(handle
);
1889 if ((err
= ext4_orphan_add(handle
, inode
)) != 0)
1892 if ((err
= ext4_get_inode_loc(inode
, &is
.iloc
)) != 0)
1895 down_write(&EXT4_I(inode
)->i_data_sem
);
1896 i_size
= inode
->i_size
;
1897 inline_size
= ext4_get_inline_size(inode
);
1898 EXT4_I(inode
)->i_disksize
= i_size
;
1900 if (i_size
< inline_size
) {
1901 /* Clear the content in the xattr space. */
1902 if (inline_size
> EXT4_MIN_INLINE_DATA_SIZE
) {
1903 if ((err
= ext4_xattr_ibody_find(inode
, &i
, &is
)) != 0)
1906 BUG_ON(is
.s
.not_found
);
1908 value_len
= le32_to_cpu(is
.s
.here
->e_value_size
);
1909 value
= kmalloc(value_len
, GFP_NOFS
);
1915 err
= ext4_xattr_ibody_get(inode
, i
.name_index
,
1916 i
.name
, value
, value_len
);
1921 i
.value_len
= i_size
> EXT4_MIN_INLINE_DATA_SIZE
?
1922 i_size
- EXT4_MIN_INLINE_DATA_SIZE
: 0;
1923 err
= ext4_xattr_ibody_inline_set(handle
, inode
,
1929 /* Clear the content within i_blocks. */
1930 if (i_size
< EXT4_MIN_INLINE_DATA_SIZE
) {
1931 void *p
= (void *) ext4_raw_inode(&is
.iloc
)->i_block
;
1932 memset(p
+ i_size
, 0,
1933 EXT4_MIN_INLINE_DATA_SIZE
- i_size
);
1936 EXT4_I(inode
)->i_inline_size
= i_size
<
1937 EXT4_MIN_INLINE_DATA_SIZE
?
1938 EXT4_MIN_INLINE_DATA_SIZE
: i_size
;
1942 up_write(&EXT4_I(inode
)->i_data_sem
);
1945 ext4_write_unlock_xattr(inode
, &no_expand
);
1948 ext4_orphan_del(handle
, inode
);
1951 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1952 err
= ext4_mark_inode_dirty(handle
, inode
);
1954 ext4_handle_sync(handle
);
1956 ext4_journal_stop(handle
);
1960 int ext4_convert_inline_data(struct inode
*inode
)
1962 int error
, needed_blocks
, no_expand
;
1964 struct ext4_iloc iloc
;
1966 if (!ext4_has_inline_data(inode
)) {
1967 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1971 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1974 error
= ext4_get_inode_loc(inode
, &iloc
);
1978 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
1979 if (IS_ERR(handle
)) {
1980 error
= PTR_ERR(handle
);
1984 ext4_write_lock_xattr(inode
, &no_expand
);
1985 if (ext4_has_inline_data(inode
))
1986 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
1987 ext4_write_unlock_xattr(inode
, &no_expand
);
1988 ext4_journal_stop(handle
);