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>
10 #include <linux/backing-dev.h>
12 #include "ext4_jbd2.h"
17 #define EXT4_XATTR_SYSTEM_DATA "data"
18 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS))
19 #define EXT4_INLINE_DOTDOT_OFFSET 2
20 #define EXT4_INLINE_DOTDOT_SIZE 4
22 static int ext4_get_inline_size(struct inode
*inode
)
24 if (EXT4_I(inode
)->i_inline_off
)
25 return EXT4_I(inode
)->i_inline_size
;
30 static int get_max_inline_xattr_value_size(struct inode
*inode
,
31 struct ext4_iloc
*iloc
)
33 struct ext4_xattr_ibody_header
*header
;
34 struct ext4_xattr_entry
*entry
;
35 struct ext4_inode
*raw_inode
;
38 min_offs
= EXT4_SB(inode
->i_sb
)->s_inode_size
-
39 EXT4_GOOD_OLD_INODE_SIZE
-
40 EXT4_I(inode
)->i_extra_isize
-
41 sizeof(struct ext4_xattr_ibody_header
);
44 * We need to subtract another sizeof(__u32) since an in-inode xattr
45 * needs an empty 4 bytes to indicate the gap between the xattr entry
46 * and the name/value pair.
48 if (!ext4_test_inode_state(inode
, EXT4_STATE_XATTR
))
49 return EXT4_XATTR_SIZE(min_offs
-
50 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
)) -
51 EXT4_XATTR_ROUND
- sizeof(__u32
));
53 raw_inode
= ext4_raw_inode(iloc
);
54 header
= IHDR(inode
, raw_inode
);
55 entry
= IFIRST(header
);
57 /* Compute min_offs. */
58 for (; !IS_LAST_ENTRY(entry
); entry
= EXT4_XATTR_NEXT(entry
)) {
59 if (!entry
->e_value_inum
&& entry
->e_value_size
) {
60 size_t offs
= le16_to_cpu(entry
->e_value_offs
);
66 ((void *)entry
- (void *)IFIRST(header
)) - sizeof(__u32
);
68 if (EXT4_I(inode
)->i_inline_off
) {
69 entry
= (struct ext4_xattr_entry
*)
70 ((void *)raw_inode
+ EXT4_I(inode
)->i_inline_off
);
72 free
+= EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
));
76 free
-= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
));
78 if (free
> EXT4_XATTR_ROUND
)
79 free
= EXT4_XATTR_SIZE(free
- EXT4_XATTR_ROUND
);
88 * Get the maximum size we now can store in an inode.
89 * If we can't find the space for a xattr entry, don't use the space
90 * of the extents since we have no space to indicate the inline data.
92 int ext4_get_max_inline_size(struct inode
*inode
)
94 int error
, max_inline_size
;
95 struct ext4_iloc iloc
;
97 if (EXT4_I(inode
)->i_extra_isize
== 0)
100 error
= ext4_get_inode_loc(inode
, &iloc
);
102 ext4_error_inode_err(inode
, __func__
, __LINE__
, 0, -error
,
103 "can't get inode location %lu",
108 down_read(&EXT4_I(inode
)->xattr_sem
);
109 max_inline_size
= get_max_inline_xattr_value_size(inode
, &iloc
);
110 up_read(&EXT4_I(inode
)->xattr_sem
);
114 if (!max_inline_size
)
117 return max_inline_size
+ EXT4_MIN_INLINE_DATA_SIZE
;
121 * this function does not take xattr_sem, which is OK because it is
122 * currently only used in a code path coming form ext4_iget, before
123 * the new inode has been unlocked
125 int ext4_find_inline_data_nolock(struct inode
*inode
)
127 struct ext4_xattr_ibody_find is
= {
128 .s
= { .not_found
= -ENODATA
, },
130 struct ext4_xattr_info i
= {
131 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
132 .name
= EXT4_XATTR_SYSTEM_DATA
,
136 if (EXT4_I(inode
)->i_extra_isize
== 0)
139 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
143 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
147 if (!is
.s
.not_found
) {
148 if (is
.s
.here
->e_value_inum
) {
149 EXT4_ERROR_INODE(inode
, "inline data xattr refers "
150 "to an external xattr inode");
151 error
= -EFSCORRUPTED
;
154 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
155 (void *)ext4_raw_inode(&is
.iloc
));
156 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
157 le32_to_cpu(is
.s
.here
->e_value_size
);
158 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
165 static int ext4_read_inline_data(struct inode
*inode
, void *buffer
,
167 struct ext4_iloc
*iloc
)
169 struct ext4_xattr_entry
*entry
;
170 struct ext4_xattr_ibody_header
*header
;
172 struct ext4_inode
*raw_inode
;
177 BUG_ON(len
> EXT4_I(inode
)->i_inline_size
);
179 cp_len
= len
< EXT4_MIN_INLINE_DATA_SIZE
?
180 len
: EXT4_MIN_INLINE_DATA_SIZE
;
182 raw_inode
= ext4_raw_inode(iloc
);
183 memcpy(buffer
, (void *)(raw_inode
->i_block
), cp_len
);
191 header
= IHDR(inode
, raw_inode
);
192 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
193 EXT4_I(inode
)->i_inline_off
);
194 len
= min_t(unsigned int, len
,
195 (unsigned int)le32_to_cpu(entry
->e_value_size
));
198 (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
), len
);
206 * write the buffer to the inline inode.
207 * If 'create' is set, we don't need to do the extra copy in the xattr
208 * value since it is already handled by ext4_xattr_ibody_set.
209 * That saves us one memcpy.
211 static void ext4_write_inline_data(struct inode
*inode
, struct ext4_iloc
*iloc
,
212 void *buffer
, loff_t pos
, unsigned int len
)
214 struct ext4_xattr_entry
*entry
;
215 struct ext4_xattr_ibody_header
*header
;
216 struct ext4_inode
*raw_inode
;
219 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
222 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
223 BUG_ON(pos
+ len
> EXT4_I(inode
)->i_inline_size
);
225 raw_inode
= ext4_raw_inode(iloc
);
228 if (pos
< EXT4_MIN_INLINE_DATA_SIZE
) {
229 cp_len
= pos
+ len
> EXT4_MIN_INLINE_DATA_SIZE
?
230 EXT4_MIN_INLINE_DATA_SIZE
- pos
: len
;
231 memcpy((void *)raw_inode
->i_block
+ pos
, buffer
, cp_len
);
241 pos
-= EXT4_MIN_INLINE_DATA_SIZE
;
242 header
= IHDR(inode
, raw_inode
);
243 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
244 EXT4_I(inode
)->i_inline_off
);
246 memcpy((void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
) + pos
,
250 static int ext4_create_inline_data(handle_t
*handle
,
251 struct inode
*inode
, unsigned len
)
255 struct ext4_xattr_ibody_find is
= {
256 .s
= { .not_found
= -ENODATA
, },
258 struct ext4_xattr_info i
= {
259 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
260 .name
= EXT4_XATTR_SYSTEM_DATA
,
263 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
267 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
268 error
= ext4_journal_get_write_access(handle
, inode
->i_sb
, is
.iloc
.bh
,
273 if (len
> EXT4_MIN_INLINE_DATA_SIZE
) {
274 value
= EXT4_ZERO_XATTR_VALUE
;
275 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
281 /* Insert the xttr entry. */
285 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
289 BUG_ON(!is
.s
.not_found
);
291 error
= ext4_xattr_ibody_set(handle
, inode
, &i
, &is
);
293 if (error
== -ENOSPC
)
294 ext4_clear_inode_state(inode
,
295 EXT4_STATE_MAY_INLINE_DATA
);
299 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
300 0, EXT4_MIN_INLINE_DATA_SIZE
);
302 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
303 (void *)ext4_raw_inode(&is
.iloc
));
304 EXT4_I(inode
)->i_inline_size
= len
+ EXT4_MIN_INLINE_DATA_SIZE
;
305 ext4_clear_inode_flag(inode
, EXT4_INODE_EXTENTS
);
306 ext4_set_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
308 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
315 static int ext4_update_inline_data(handle_t
*handle
, struct inode
*inode
,
320 struct ext4_xattr_ibody_find is
= {
321 .s
= { .not_found
= -ENODATA
, },
323 struct ext4_xattr_info i
= {
324 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
325 .name
= EXT4_XATTR_SYSTEM_DATA
,
328 /* If the old space is ok, write the data directly. */
329 if (len
<= EXT4_I(inode
)->i_inline_size
)
332 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
336 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
340 BUG_ON(is
.s
.not_found
);
342 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
343 value
= kzalloc(len
, GFP_NOFS
);
349 error
= ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
351 if (error
== -ENODATA
)
354 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
355 error
= ext4_journal_get_write_access(handle
, inode
->i_sb
, is
.iloc
.bh
,
360 /* Update the xattr entry. */
364 error
= ext4_xattr_ibody_set(handle
, inode
, &i
, &is
);
368 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
369 (void *)ext4_raw_inode(&is
.iloc
));
370 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
371 le32_to_cpu(is
.s
.here
->e_value_size
);
372 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
374 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
382 static int ext4_prepare_inline_data(handle_t
*handle
, struct inode
*inode
,
385 int ret
, size
, no_expand
;
386 struct ext4_inode_info
*ei
= EXT4_I(inode
);
388 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
))
391 size
= ext4_get_max_inline_size(inode
);
395 ext4_write_lock_xattr(inode
, &no_expand
);
397 if (ei
->i_inline_off
)
398 ret
= ext4_update_inline_data(handle
, inode
, len
);
400 ret
= ext4_create_inline_data(handle
, inode
, len
);
402 ext4_write_unlock_xattr(inode
, &no_expand
);
406 static int ext4_destroy_inline_data_nolock(handle_t
*handle
,
409 struct ext4_inode_info
*ei
= EXT4_I(inode
);
410 struct ext4_xattr_ibody_find is
= {
411 .s
= { .not_found
= 0, },
413 struct ext4_xattr_info i
= {
414 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
415 .name
= EXT4_XATTR_SYSTEM_DATA
,
421 if (!ei
->i_inline_off
)
424 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
428 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
432 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
433 error
= ext4_journal_get_write_access(handle
, inode
->i_sb
, is
.iloc
.bh
,
438 error
= ext4_xattr_ibody_set(handle
, inode
, &i
, &is
);
442 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
443 0, EXT4_MIN_INLINE_DATA_SIZE
);
444 memset(ei
->i_data
, 0, EXT4_MIN_INLINE_DATA_SIZE
);
446 if (ext4_has_feature_extents(inode
->i_sb
)) {
447 if (S_ISDIR(inode
->i_mode
) ||
448 S_ISREG(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) {
449 ext4_set_inode_flag(inode
, EXT4_INODE_EXTENTS
);
450 ext4_ext_tree_init(handle
, inode
);
453 ext4_clear_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
456 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
458 EXT4_I(inode
)->i_inline_off
= 0;
459 EXT4_I(inode
)->i_inline_size
= 0;
460 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
463 if (error
== -ENODATA
)
468 static int ext4_read_inline_page(struct inode
*inode
, struct page
*page
)
473 struct ext4_iloc iloc
;
475 BUG_ON(!PageLocked(page
));
476 BUG_ON(!ext4_has_inline_data(inode
));
479 if (!EXT4_I(inode
)->i_inline_off
) {
480 ext4_warning(inode
->i_sb
, "inode %lu doesn't have inline data.",
485 ret
= ext4_get_inode_loc(inode
, &iloc
);
489 len
= min_t(size_t, ext4_get_inline_size(inode
), i_size_read(inode
));
490 kaddr
= kmap_atomic(page
);
491 ret
= ext4_read_inline_data(inode
, kaddr
, len
, &iloc
);
492 flush_dcache_page(page
);
493 kunmap_atomic(kaddr
);
494 zero_user_segment(page
, len
, PAGE_SIZE
);
495 SetPageUptodate(page
);
502 int ext4_readpage_inline(struct inode
*inode
, struct page
*page
)
506 down_read(&EXT4_I(inode
)->xattr_sem
);
507 if (!ext4_has_inline_data(inode
)) {
508 up_read(&EXT4_I(inode
)->xattr_sem
);
513 * Current inline data can only exist in the 1st page,
514 * So for all the other pages, just set them uptodate.
517 ret
= ext4_read_inline_page(inode
, page
);
518 else if (!PageUptodate(page
)) {
519 zero_user_segment(page
, 0, PAGE_SIZE
);
520 SetPageUptodate(page
);
523 up_read(&EXT4_I(inode
)->xattr_sem
);
526 return ret
>= 0 ? 0 : ret
;
529 static int ext4_convert_inline_data_to_extent(struct address_space
*mapping
,
533 int ret
, needed_blocks
, no_expand
;
534 handle_t
*handle
= NULL
;
535 int retries
= 0, sem_held
= 0;
536 struct page
*page
= NULL
;
538 struct ext4_iloc iloc
;
540 if (!ext4_has_inline_data(inode
)) {
542 * clear the flag so that no new write
543 * will trap here again.
545 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
549 needed_blocks
= ext4_writepage_trans_blocks(inode
);
551 ret
= ext4_get_inode_loc(inode
, &iloc
);
556 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
557 if (IS_ERR(handle
)) {
558 ret
= PTR_ERR(handle
);
563 /* We cannot recurse into the filesystem as the transaction is already
565 flags
|= AOP_FLAG_NOFS
;
567 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
573 ext4_write_lock_xattr(inode
, &no_expand
);
575 /* If some one has already done this for us, just exit. */
576 if (!ext4_has_inline_data(inode
)) {
582 to
= ext4_get_inline_size(inode
);
583 if (!PageUptodate(page
)) {
584 ret
= ext4_read_inline_page(inode
, page
);
589 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
593 if (ext4_should_dioread_nolock(inode
)) {
594 ret
= __block_write_begin(page
, from
, to
,
595 ext4_get_block_unwritten
);
597 ret
= __block_write_begin(page
, from
, to
, ext4_get_block
);
599 if (!ret
&& ext4_should_journal_data(inode
)) {
600 ret
= ext4_walk_page_buffers(handle
, inode
, page_buffers(page
),
602 do_journal_get_write_access
);
609 ext4_orphan_add(handle
, inode
);
610 ext4_write_unlock_xattr(inode
, &no_expand
);
612 ext4_journal_stop(handle
);
614 ext4_truncate_failed_write(inode
);
616 * If truncate failed early the inode might
617 * still be on the orphan list; we need to
618 * make sure the inode is removed from the
619 * orphan list in that case.
622 ext4_orphan_del(NULL
, inode
);
625 if (ret
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
629 block_commit_write(page
, from
, to
);
636 ext4_write_unlock_xattr(inode
, &no_expand
);
638 ext4_journal_stop(handle
);
644 * Try to write data in the inode.
645 * If the inode has inline data, check whether the new write can be
646 * in the inode also. If not, create the page the handle, move the data
647 * to the page make it update and let the later codes create extent for it.
649 int ext4_try_to_write_inline_data(struct address_space
*mapping
,
651 loff_t pos
, unsigned len
,
658 struct ext4_iloc iloc
;
660 if (pos
+ len
> ext4_get_max_inline_size(inode
))
663 ret
= ext4_get_inode_loc(inode
, &iloc
);
668 * The possible write could happen in the inode,
669 * so try to reserve the space in inode first.
671 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
672 if (IS_ERR(handle
)) {
673 ret
= PTR_ERR(handle
);
678 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
679 if (ret
&& ret
!= -ENOSPC
)
682 /* We don't have space in inline inode, so convert it to extent. */
683 if (ret
== -ENOSPC
) {
684 ext4_journal_stop(handle
);
689 ret
= ext4_journal_get_write_access(handle
, inode
->i_sb
, iloc
.bh
,
694 flags
|= AOP_FLAG_NOFS
;
696 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
703 down_read(&EXT4_I(inode
)->xattr_sem
);
704 if (!ext4_has_inline_data(inode
)) {
711 if (!PageUptodate(page
)) {
712 ret
= ext4_read_inline_page(inode
, page
);
723 up_read(&EXT4_I(inode
)->xattr_sem
);
725 if (handle
&& (ret
!= 1))
726 ext4_journal_stop(handle
);
730 return ext4_convert_inline_data_to_extent(mapping
,
734 int ext4_write_inline_data_end(struct inode
*inode
, loff_t pos
, unsigned len
,
735 unsigned copied
, struct page
*page
)
737 handle_t
*handle
= ext4_journal_current_handle();
740 struct ext4_iloc iloc
;
743 if (unlikely(copied
< len
) && !PageUptodate(page
))
746 if (likely(copied
)) {
747 ret
= ext4_get_inode_loc(inode
, &iloc
);
751 ext4_std_error(inode
->i_sb
, ret
);
754 ext4_write_lock_xattr(inode
, &no_expand
);
755 BUG_ON(!ext4_has_inline_data(inode
));
758 * ei->i_inline_off may have changed since
759 * ext4_write_begin() called
760 * ext4_try_to_write_inline_data()
762 (void) ext4_find_inline_data_nolock(inode
);
764 kaddr
= kmap_atomic(page
);
765 ext4_write_inline_data(inode
, &iloc
, kaddr
, pos
, copied
);
766 kunmap_atomic(kaddr
);
767 SetPageUptodate(page
);
768 /* clear page dirty so that writepages wouldn't work for us. */
769 ClearPageDirty(page
);
771 ext4_write_unlock_xattr(inode
, &no_expand
);
775 * It's important to update i_size while still holding page
776 * lock: page writeout could otherwise come in and zero
779 ext4_update_inode_size(inode
, pos
+ copied
);
785 * Don't mark the inode dirty under page lock. First, it unnecessarily
786 * makes the holding time of page lock longer. Second, it forces lock
787 * ordering of page lock and transaction start for journaling
791 mark_inode_dirty(inode
);
794 * If we didn't copy as much data as expected, we need to trim back
795 * size of xattr containing inline data.
797 if (pos
+ len
> inode
->i_size
&& ext4_can_truncate(inode
))
798 ext4_orphan_add(handle
, inode
);
800 ret2
= ext4_journal_stop(handle
);
803 if (pos
+ len
> inode
->i_size
) {
804 ext4_truncate_failed_write(inode
);
806 * If truncate failed early the inode might still be
807 * on the orphan list; we need to make sure the inode
808 * is removed from the orphan list in that case.
811 ext4_orphan_del(NULL
, inode
);
813 return ret
? ret
: copied
;
817 ext4_journalled_write_inline_data(struct inode
*inode
,
823 struct ext4_iloc iloc
;
825 ret
= ext4_get_inode_loc(inode
, &iloc
);
827 ext4_std_error(inode
->i_sb
, ret
);
831 ext4_write_lock_xattr(inode
, &no_expand
);
832 kaddr
= kmap_atomic(page
);
833 ext4_write_inline_data(inode
, &iloc
, kaddr
, 0, len
);
834 kunmap_atomic(kaddr
);
835 ext4_write_unlock_xattr(inode
, &no_expand
);
841 * Try to make the page cache and handle ready for the inline data case.
842 * We can call this function in 2 cases:
843 * 1. The inode is created and the first write exceeds inline size. We can
844 * clear the inode state safely.
845 * 2. The inode has inline data, then we need to read the data, make it
846 * update and dirty so that ext4_da_writepages can handle it. We don't
847 * need to start the journal since the file's metadata isn't changed now.
849 static int ext4_da_convert_inline_data_to_extent(struct address_space
*mapping
,
854 int ret
= 0, inline_size
;
857 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
861 down_read(&EXT4_I(inode
)->xattr_sem
);
862 if (!ext4_has_inline_data(inode
)) {
863 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
867 inline_size
= ext4_get_inline_size(inode
);
869 if (!PageUptodate(page
)) {
870 ret
= ext4_read_inline_page(inode
, page
);
875 ret
= __block_write_begin(page
, 0, inline_size
,
876 ext4_da_get_block_prep
);
878 up_read(&EXT4_I(inode
)->xattr_sem
);
881 ext4_truncate_failed_write(inode
);
886 SetPageUptodate(page
);
887 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
888 *fsdata
= (void *)CONVERT_INLINE_DATA
;
891 up_read(&EXT4_I(inode
)->xattr_sem
);
900 * Prepare the write for the inline data.
901 * If the data can be written into the inode, we just read
902 * the page and make it uptodate, and start the journal.
903 * Otherwise read the page, makes it dirty so that it can be
904 * handle in writepages(the i_disksize update is left to the
905 * normal ext4_da_write_end).
907 int ext4_da_write_inline_data_begin(struct address_space
*mapping
,
909 loff_t pos
, unsigned len
,
914 int ret
, inline_size
;
917 struct ext4_iloc iloc
;
920 ret
= ext4_get_inode_loc(inode
, &iloc
);
925 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
926 if (IS_ERR(handle
)) {
927 ret
= PTR_ERR(handle
);
931 inline_size
= ext4_get_max_inline_size(inode
);
934 if (inline_size
>= pos
+ len
) {
935 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
936 if (ret
&& ret
!= -ENOSPC
)
941 * We cannot recurse into the filesystem as the transaction
942 * is already started.
944 flags
|= AOP_FLAG_NOFS
;
946 if (ret
== -ENOSPC
) {
947 ext4_journal_stop(handle
);
948 ret
= ext4_da_convert_inline_data_to_extent(mapping
,
952 if (ret
== -ENOSPC
&&
953 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
958 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
964 down_read(&EXT4_I(inode
)->xattr_sem
);
965 if (!ext4_has_inline_data(inode
)) {
967 goto out_release_page
;
970 if (!PageUptodate(page
)) {
971 ret
= ext4_read_inline_page(inode
, page
);
973 goto out_release_page
;
975 ret
= ext4_journal_get_write_access(handle
, inode
->i_sb
, iloc
.bh
,
978 goto out_release_page
;
980 up_read(&EXT4_I(inode
)->xattr_sem
);
985 up_read(&EXT4_I(inode
)->xattr_sem
);
989 ext4_journal_stop(handle
);
995 #ifdef INLINE_DIR_DEBUG
996 void ext4_show_inline_dir(struct inode
*dir
, struct buffer_head
*bh
,
997 void *inline_start
, int inline_size
)
1000 unsigned short de_len
;
1001 struct ext4_dir_entry_2
*de
= inline_start
;
1002 void *dlimit
= inline_start
+ inline_size
;
1004 trace_printk("inode %lu\n", dir
->i_ino
);
1006 while ((void *)de
< dlimit
) {
1007 de_len
= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1008 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
1009 offset
, de_len
, de
->name_len
, de
->name
,
1010 de
->name_len
, le32_to_cpu(de
->inode
));
1011 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
1012 inline_start
, inline_size
, offset
))
1016 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
1020 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
1024 * Add a new entry into a inline dir.
1025 * It will return -ENOSPC if no space is available, and -EIO
1026 * and -EEXIST if directory entry already exists.
1028 static int ext4_add_dirent_to_inline(handle_t
*handle
,
1029 struct ext4_filename
*fname
,
1031 struct inode
*inode
,
1032 struct ext4_iloc
*iloc
,
1033 void *inline_start
, int inline_size
)
1036 struct ext4_dir_entry_2
*de
;
1038 err
= ext4_find_dest_de(dir
, inode
, iloc
->bh
, inline_start
,
1039 inline_size
, fname
, &de
);
1043 BUFFER_TRACE(iloc
->bh
, "get_write_access");
1044 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, iloc
->bh
,
1048 ext4_insert_dentry(dir
, inode
, de
, inline_size
, fname
);
1050 ext4_show_inline_dir(dir
, iloc
->bh
, inline_start
, inline_size
);
1053 * XXX shouldn't update any times until successful
1054 * completion of syscall, but too many callers depend
1057 * XXX similarly, too many callers depend on
1058 * ext4_new_inode() setting the times, but error
1059 * recovery deletes the inode, so the worst that can
1060 * happen is that the times are slightly out of date
1061 * and/or different from the directory change time.
1063 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1064 ext4_update_dx_flag(dir
);
1065 inode_inc_iversion(dir
);
1069 static void *ext4_get_inline_xattr_pos(struct inode
*inode
,
1070 struct ext4_iloc
*iloc
)
1072 struct ext4_xattr_entry
*entry
;
1073 struct ext4_xattr_ibody_header
*header
;
1075 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
1077 header
= IHDR(inode
, ext4_raw_inode(iloc
));
1078 entry
= (struct ext4_xattr_entry
*)((void *)ext4_raw_inode(iloc
) +
1079 EXT4_I(inode
)->i_inline_off
);
1081 return (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
);
1084 /* Set the final de to cover the whole block. */
1085 static void ext4_update_final_de(void *de_buf
, int old_size
, int new_size
)
1087 struct ext4_dir_entry_2
*de
, *prev_de
;
1091 de
= (struct ext4_dir_entry_2
*)de_buf
;
1093 limit
= de_buf
+ old_size
;
1096 de_len
= ext4_rec_len_from_disk(de
->rec_len
, old_size
);
1098 de
= (struct ext4_dir_entry_2
*)de_buf
;
1099 } while (de_buf
< limit
);
1101 prev_de
->rec_len
= ext4_rec_len_to_disk(de_len
+ new_size
-
1102 old_size
, new_size
);
1104 /* this is just created, so create an empty entry. */
1106 de
->rec_len
= ext4_rec_len_to_disk(new_size
, new_size
);
1110 static int ext4_update_inline_dir(handle_t
*handle
, struct inode
*dir
,
1111 struct ext4_iloc
*iloc
)
1114 int old_size
= EXT4_I(dir
)->i_inline_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1115 int new_size
= get_max_inline_xattr_value_size(dir
, iloc
);
1117 if (new_size
- old_size
<= ext4_dir_rec_len(1, NULL
))
1120 ret
= ext4_update_inline_data(handle
, dir
,
1121 new_size
+ EXT4_MIN_INLINE_DATA_SIZE
);
1125 ext4_update_final_de(ext4_get_inline_xattr_pos(dir
, iloc
), old_size
,
1126 EXT4_I(dir
)->i_inline_size
-
1127 EXT4_MIN_INLINE_DATA_SIZE
);
1128 dir
->i_size
= EXT4_I(dir
)->i_disksize
= EXT4_I(dir
)->i_inline_size
;
1132 static void ext4_restore_inline_data(handle_t
*handle
, struct inode
*inode
,
1133 struct ext4_iloc
*iloc
,
1134 void *buf
, int inline_size
)
1138 ret
= ext4_create_inline_data(handle
, inode
, inline_size
);
1140 ext4_msg(inode
->i_sb
, KERN_EMERG
,
1141 "error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)",
1145 ext4_write_inline_data(inode
, iloc
, buf
, 0, inline_size
);
1146 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1149 static int ext4_finish_convert_inline_dir(handle_t
*handle
,
1150 struct inode
*inode
,
1151 struct buffer_head
*dir_block
,
1155 int err
, csum_size
= 0, header_size
= 0;
1156 struct ext4_dir_entry_2
*de
;
1157 void *target
= dir_block
->b_data
;
1160 * First create "." and ".." and then copy the dir information
1161 * back to the block.
1163 de
= (struct ext4_dir_entry_2
*)target
;
1164 de
= ext4_init_dot_dotdot(inode
, de
,
1165 inode
->i_sb
->s_blocksize
, csum_size
,
1166 le32_to_cpu(((struct ext4_dir_entry_2
*)buf
)->inode
), 1);
1167 header_size
= (void *)de
- target
;
1169 memcpy((void *)de
, buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1170 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1172 if (ext4_has_metadata_csum(inode
->i_sb
))
1173 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1175 inode
->i_size
= inode
->i_sb
->s_blocksize
;
1176 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
1177 EXT4_I(inode
)->i_disksize
= inode
->i_sb
->s_blocksize
;
1178 ext4_update_final_de(dir_block
->b_data
,
1179 inline_size
- EXT4_INLINE_DOTDOT_SIZE
+ header_size
,
1180 inode
->i_sb
->s_blocksize
- csum_size
);
1183 ext4_initialize_dirent_tail(dir_block
,
1184 inode
->i_sb
->s_blocksize
);
1185 set_buffer_uptodate(dir_block
);
1186 err
= ext4_handle_dirty_dirblock(handle
, inode
, dir_block
);
1189 set_buffer_verified(dir_block
);
1190 return ext4_mark_inode_dirty(handle
, inode
);
1193 static int ext4_convert_inline_data_nolock(handle_t
*handle
,
1194 struct inode
*inode
,
1195 struct ext4_iloc
*iloc
)
1199 struct buffer_head
*data_bh
= NULL
;
1200 struct ext4_map_blocks map
;
1203 inline_size
= ext4_get_inline_size(inode
);
1204 buf
= kmalloc(inline_size
, GFP_NOFS
);
1210 error
= ext4_read_inline_data(inode
, buf
, inline_size
, iloc
);
1215 * Make sure the inline directory entries pass checks before we try to
1216 * convert them, so that we avoid touching stuff that needs fsck.
1218 if (S_ISDIR(inode
->i_mode
)) {
1219 error
= ext4_check_all_de(inode
, iloc
->bh
,
1220 buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1221 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1226 error
= ext4_destroy_inline_data_nolock(handle
, inode
);
1233 error
= ext4_map_blocks(handle
, inode
, &map
, EXT4_GET_BLOCKS_CREATE
);
1236 if (!(map
.m_flags
& EXT4_MAP_MAPPED
)) {
1241 data_bh
= sb_getblk(inode
->i_sb
, map
.m_pblk
);
1247 lock_buffer(data_bh
);
1248 error
= ext4_journal_get_create_access(handle
, inode
->i_sb
, data_bh
,
1251 unlock_buffer(data_bh
);
1255 memset(data_bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1257 if (!S_ISDIR(inode
->i_mode
)) {
1258 memcpy(data_bh
->b_data
, buf
, inline_size
);
1259 set_buffer_uptodate(data_bh
);
1260 error
= ext4_handle_dirty_metadata(handle
,
1263 error
= ext4_finish_convert_inline_dir(handle
, inode
, data_bh
,
1267 unlock_buffer(data_bh
);
1270 ext4_restore_inline_data(handle
, inode
, iloc
, buf
, inline_size
);
1279 * Try to add the new entry to the inline data.
1280 * If succeeds, return 0. If not, extended the inline dir and copied data to
1281 * the new created block.
1283 int ext4_try_add_inline_entry(handle_t
*handle
, struct ext4_filename
*fname
,
1284 struct inode
*dir
, struct inode
*inode
)
1286 int ret
, ret2
, inline_size
, no_expand
;
1288 struct ext4_iloc iloc
;
1290 ret
= ext4_get_inode_loc(dir
, &iloc
);
1294 ext4_write_lock_xattr(dir
, &no_expand
);
1295 if (!ext4_has_inline_data(dir
))
1298 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1299 EXT4_INLINE_DOTDOT_SIZE
;
1300 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1302 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
, inode
, &iloc
,
1303 inline_start
, inline_size
);
1307 /* check whether it can be inserted to inline xattr space. */
1308 inline_size
= EXT4_I(dir
)->i_inline_size
-
1309 EXT4_MIN_INLINE_DATA_SIZE
;
1311 /* Try to use the xattr space.*/
1312 ret
= ext4_update_inline_dir(handle
, dir
, &iloc
);
1313 if (ret
&& ret
!= -ENOSPC
)
1316 inline_size
= EXT4_I(dir
)->i_inline_size
-
1317 EXT4_MIN_INLINE_DATA_SIZE
;
1321 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1323 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
,
1324 inode
, &iloc
, inline_start
,
1332 * The inline space is filled up, so create a new block for it.
1333 * As the extent tree will be created, we have to save the inline
1336 ret
= ext4_convert_inline_data_nolock(handle
, dir
, &iloc
);
1339 ext4_write_unlock_xattr(dir
, &no_expand
);
1340 ret2
= ext4_mark_inode_dirty(handle
, dir
);
1341 if (unlikely(ret2
&& !ret
))
1348 * This function fills a red-black tree with information from an
1349 * inlined dir. It returns the number directory entries loaded
1350 * into the tree. If there is an error it is returned in err.
1352 int ext4_inlinedir_to_tree(struct file
*dir_file
,
1353 struct inode
*dir
, ext4_lblk_t block
,
1354 struct dx_hash_info
*hinfo
,
1355 __u32 start_hash
, __u32 start_minor_hash
,
1356 int *has_inline_data
)
1358 int err
= 0, count
= 0;
1359 unsigned int parent_ino
;
1361 struct ext4_dir_entry_2
*de
;
1362 struct inode
*inode
= file_inode(dir_file
);
1363 int ret
, inline_size
= 0;
1364 struct ext4_iloc iloc
;
1365 void *dir_buf
= NULL
;
1366 struct ext4_dir_entry_2 fake
;
1367 struct fscrypt_str tmp_str
;
1369 ret
= ext4_get_inode_loc(inode
, &iloc
);
1373 down_read(&EXT4_I(inode
)->xattr_sem
);
1374 if (!ext4_has_inline_data(inode
)) {
1375 up_read(&EXT4_I(inode
)->xattr_sem
);
1376 *has_inline_data
= 0;
1380 inline_size
= ext4_get_inline_size(inode
);
1381 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1384 up_read(&EXT4_I(inode
)->xattr_sem
);
1388 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1389 up_read(&EXT4_I(inode
)->xattr_sem
);
1394 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1395 while (pos
< inline_size
) {
1397 * As inlined dir doesn't store any information about '.' and
1398 * only the inode number of '..' is stored, we have to handle
1402 fake
.inode
= cpu_to_le32(inode
->i_ino
);
1404 strcpy(fake
.name
, ".");
1405 fake
.rec_len
= ext4_rec_len_to_disk(
1406 ext4_dir_rec_len(fake
.name_len
, NULL
),
1408 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1410 pos
= EXT4_INLINE_DOTDOT_OFFSET
;
1411 } else if (pos
== EXT4_INLINE_DOTDOT_OFFSET
) {
1412 fake
.inode
= cpu_to_le32(parent_ino
);
1414 strcpy(fake
.name
, "..");
1415 fake
.rec_len
= ext4_rec_len_to_disk(
1416 ext4_dir_rec_len(fake
.name_len
, NULL
),
1418 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1420 pos
= EXT4_INLINE_DOTDOT_SIZE
;
1422 de
= (struct ext4_dir_entry_2
*)(dir_buf
+ pos
);
1423 pos
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1424 if (ext4_check_dir_entry(inode
, dir_file
, de
,
1426 inline_size
, pos
)) {
1432 if (ext4_hash_in_dirent(dir
)) {
1433 hinfo
->hash
= EXT4_DIRENT_HASH(de
);
1434 hinfo
->minor_hash
= EXT4_DIRENT_MINOR_HASH(de
);
1436 ext4fs_dirhash(dir
, de
->name
, de
->name_len
, hinfo
);
1438 if ((hinfo
->hash
< start_hash
) ||
1439 ((hinfo
->hash
== start_hash
) &&
1440 (hinfo
->minor_hash
< start_minor_hash
)))
1444 tmp_str
.name
= de
->name
;
1445 tmp_str
.len
= de
->name_len
;
1446 err
= ext4_htree_store_dirent(dir_file
, hinfo
->hash
,
1447 hinfo
->minor_hash
, de
, &tmp_str
);
1462 * So this function is called when the volume is mkfsed with
1463 * dir_index disabled. In order to keep f_pos persistent
1464 * after we convert from an inlined dir to a blocked based,
1465 * we just pretend that we are a normal dir and return the
1466 * offset as if '.' and '..' really take place.
1469 int ext4_read_inline_dir(struct file
*file
,
1470 struct dir_context
*ctx
,
1471 int *has_inline_data
)
1473 unsigned int offset
, parent_ino
;
1475 struct ext4_dir_entry_2
*de
;
1476 struct super_block
*sb
;
1477 struct inode
*inode
= file_inode(file
);
1478 int ret
, inline_size
= 0;
1479 struct ext4_iloc iloc
;
1480 void *dir_buf
= NULL
;
1481 int dotdot_offset
, dotdot_size
, extra_offset
, extra_size
;
1483 ret
= ext4_get_inode_loc(inode
, &iloc
);
1487 down_read(&EXT4_I(inode
)->xattr_sem
);
1488 if (!ext4_has_inline_data(inode
)) {
1489 up_read(&EXT4_I(inode
)->xattr_sem
);
1490 *has_inline_data
= 0;
1494 inline_size
= ext4_get_inline_size(inode
);
1495 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1498 up_read(&EXT4_I(inode
)->xattr_sem
);
1502 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1503 up_read(&EXT4_I(inode
)->xattr_sem
);
1509 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1513 * dotdot_offset and dotdot_size is the real offset and
1514 * size for ".." and "." if the dir is block based while
1515 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1516 * So we will use extra_offset and extra_size to indicate them
1517 * during the inline dir iteration.
1519 dotdot_offset
= ext4_dir_rec_len(1, NULL
);
1520 dotdot_size
= dotdot_offset
+ ext4_dir_rec_len(2, NULL
);
1521 extra_offset
= dotdot_size
- EXT4_INLINE_DOTDOT_SIZE
;
1522 extra_size
= extra_offset
+ inline_size
;
1525 * If the version has changed since the last call to
1526 * readdir(2), then we might be pointing to an invalid
1527 * dirent right now. Scan from the start of the inline
1530 if (!inode_eq_iversion(inode
, file
->f_version
)) {
1531 for (i
= 0; i
< extra_size
&& i
< offset
;) {
1533 * "." is with offset 0 and
1534 * ".." is dotdot_offset.
1539 } else if (i
== dotdot_offset
) {
1543 /* for other entry, the real offset in
1544 * the buf has to be tuned accordingly.
1546 de
= (struct ext4_dir_entry_2
*)
1547 (dir_buf
+ i
- extra_offset
);
1548 /* It's too expensive to do a full
1549 * dirent test each time round this
1550 * loop, but we do have to test at
1551 * least that it is non-zero. A
1552 * failure will be detected in the
1553 * dirent test below. */
1554 if (ext4_rec_len_from_disk(de
->rec_len
, extra_size
)
1555 < ext4_dir_rec_len(1, NULL
))
1557 i
+= ext4_rec_len_from_disk(de
->rec_len
,
1562 file
->f_version
= inode_query_iversion(inode
);
1565 while (ctx
->pos
< extra_size
) {
1566 if (ctx
->pos
== 0) {
1567 if (!dir_emit(ctx
, ".", 1, inode
->i_ino
, DT_DIR
))
1569 ctx
->pos
= dotdot_offset
;
1573 if (ctx
->pos
== dotdot_offset
) {
1574 if (!dir_emit(ctx
, "..", 2, parent_ino
, DT_DIR
))
1576 ctx
->pos
= dotdot_size
;
1580 de
= (struct ext4_dir_entry_2
*)
1581 (dir_buf
+ ctx
->pos
- extra_offset
);
1582 if (ext4_check_dir_entry(inode
, file
, de
, iloc
.bh
, dir_buf
,
1583 extra_size
, ctx
->pos
))
1585 if (le32_to_cpu(de
->inode
)) {
1586 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1587 le32_to_cpu(de
->inode
),
1588 get_dtype(sb
, de
->file_type
)))
1591 ctx
->pos
+= ext4_rec_len_from_disk(de
->rec_len
, extra_size
);
1599 struct buffer_head
*ext4_get_first_inline_block(struct inode
*inode
,
1600 struct ext4_dir_entry_2
**parent_de
,
1603 struct ext4_iloc iloc
;
1605 *retval
= ext4_get_inode_loc(inode
, &iloc
);
1609 *parent_de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1615 * Try to create the inline data for the new dir.
1616 * If it succeeds, return 0, otherwise return the error.
1617 * In case of ENOSPC, the caller should create the normal disk layout dir.
1619 int ext4_try_create_inline_dir(handle_t
*handle
, struct inode
*parent
,
1620 struct inode
*inode
)
1622 int ret
, inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1623 struct ext4_iloc iloc
;
1624 struct ext4_dir_entry_2
*de
;
1626 ret
= ext4_get_inode_loc(inode
, &iloc
);
1630 ret
= ext4_prepare_inline_data(handle
, inode
, inline_size
);
1635 * For inline dir, we only save the inode information for the ".."
1636 * and create a fake dentry to cover the left space.
1638 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1639 de
->inode
= cpu_to_le32(parent
->i_ino
);
1640 de
= (struct ext4_dir_entry_2
*)((void *)de
+ EXT4_INLINE_DOTDOT_SIZE
);
1642 de
->rec_len
= ext4_rec_len_to_disk(
1643 inline_size
- EXT4_INLINE_DOTDOT_SIZE
,
1645 set_nlink(inode
, 2);
1646 inode
->i_size
= EXT4_I(inode
)->i_disksize
= inline_size
;
1652 struct buffer_head
*ext4_find_inline_entry(struct inode
*dir
,
1653 struct ext4_filename
*fname
,
1654 struct ext4_dir_entry_2
**res_dir
,
1655 int *has_inline_data
)
1658 struct ext4_iloc iloc
;
1662 if (ext4_get_inode_loc(dir
, &iloc
))
1665 down_read(&EXT4_I(dir
)->xattr_sem
);
1666 if (!ext4_has_inline_data(dir
)) {
1667 *has_inline_data
= 0;
1671 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1672 EXT4_INLINE_DOTDOT_SIZE
;
1673 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1674 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1675 dir
, fname
, 0, res_dir
);
1681 if (ext4_get_inline_size(dir
) == EXT4_MIN_INLINE_DATA_SIZE
)
1684 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1685 inline_size
= ext4_get_inline_size(dir
) - EXT4_MIN_INLINE_DATA_SIZE
;
1687 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1688 dir
, fname
, 0, res_dir
);
1696 up_read(&EXT4_I(dir
)->xattr_sem
);
1700 int ext4_delete_inline_entry(handle_t
*handle
,
1702 struct ext4_dir_entry_2
*de_del
,
1703 struct buffer_head
*bh
,
1704 int *has_inline_data
)
1706 int err
, inline_size
, no_expand
;
1707 struct ext4_iloc iloc
;
1710 err
= ext4_get_inode_loc(dir
, &iloc
);
1714 ext4_write_lock_xattr(dir
, &no_expand
);
1715 if (!ext4_has_inline_data(dir
)) {
1716 *has_inline_data
= 0;
1720 if ((void *)de_del
- ((void *)ext4_raw_inode(&iloc
)->i_block
) <
1721 EXT4_MIN_INLINE_DATA_SIZE
) {
1722 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1723 EXT4_INLINE_DOTDOT_SIZE
;
1724 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
-
1725 EXT4_INLINE_DOTDOT_SIZE
;
1727 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1728 inline_size
= ext4_get_inline_size(dir
) -
1729 EXT4_MIN_INLINE_DATA_SIZE
;
1732 BUFFER_TRACE(bh
, "get_write_access");
1733 err
= ext4_journal_get_write_access(handle
, dir
->i_sb
, bh
,
1738 err
= ext4_generic_delete_entry(dir
, de_del
, bh
,
1739 inline_start
, inline_size
, 0);
1743 ext4_show_inline_dir(dir
, iloc
.bh
, inline_start
, inline_size
);
1745 ext4_write_unlock_xattr(dir
, &no_expand
);
1746 if (likely(err
== 0))
1747 err
= ext4_mark_inode_dirty(handle
, dir
);
1750 ext4_std_error(dir
->i_sb
, err
);
1755 * Get the inline dentry at offset.
1757 static inline struct ext4_dir_entry_2
*
1758 ext4_get_inline_entry(struct inode
*inode
,
1759 struct ext4_iloc
*iloc
,
1760 unsigned int offset
,
1761 void **inline_start
,
1766 BUG_ON(offset
> ext4_get_inline_size(inode
));
1768 if (offset
< EXT4_MIN_INLINE_DATA_SIZE
) {
1769 inline_pos
= (void *)ext4_raw_inode(iloc
)->i_block
;
1770 *inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1772 inline_pos
= ext4_get_inline_xattr_pos(inode
, iloc
);
1773 offset
-= EXT4_MIN_INLINE_DATA_SIZE
;
1774 *inline_size
= ext4_get_inline_size(inode
) -
1775 EXT4_MIN_INLINE_DATA_SIZE
;
1779 *inline_start
= inline_pos
;
1780 return (struct ext4_dir_entry_2
*)(inline_pos
+ offset
);
1783 bool empty_inline_dir(struct inode
*dir
, int *has_inline_data
)
1785 int err
, inline_size
;
1786 struct ext4_iloc iloc
;
1789 unsigned int offset
;
1790 struct ext4_dir_entry_2
*de
;
1793 err
= ext4_get_inode_loc(dir
, &iloc
);
1795 EXT4_ERROR_INODE_ERR(dir
, -err
,
1796 "error %d getting inode %lu block",
1801 down_read(&EXT4_I(dir
)->xattr_sem
);
1802 if (!ext4_has_inline_data(dir
)) {
1803 *has_inline_data
= 0;
1807 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1808 if (!le32_to_cpu(de
->inode
)) {
1809 ext4_warning(dir
->i_sb
,
1810 "bad inline directory (dir #%lu) - no `..'",
1816 inline_len
= ext4_get_inline_size(dir
);
1817 offset
= EXT4_INLINE_DOTDOT_SIZE
;
1818 while (offset
< inline_len
) {
1819 de
= ext4_get_inline_entry(dir
, &iloc
, offset
,
1820 &inline_pos
, &inline_size
);
1821 if (ext4_check_dir_entry(dir
, NULL
, de
,
1822 iloc
.bh
, inline_pos
,
1823 inline_size
, offset
)) {
1824 ext4_warning(dir
->i_sb
,
1825 "bad inline directory (dir #%lu) - "
1826 "inode %u, rec_len %u, name_len %d"
1828 dir
->i_ino
, le32_to_cpu(de
->inode
),
1829 le16_to_cpu(de
->rec_len
), de
->name_len
,
1834 if (le32_to_cpu(de
->inode
)) {
1838 offset
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1842 up_read(&EXT4_I(dir
)->xattr_sem
);
1847 int ext4_destroy_inline_data(handle_t
*handle
, struct inode
*inode
)
1851 ext4_write_lock_xattr(inode
, &no_expand
);
1852 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
1853 ext4_write_unlock_xattr(inode
, &no_expand
);
1858 int ext4_inline_data_iomap(struct inode
*inode
, struct iomap
*iomap
)
1861 int error
= -EAGAIN
;
1862 struct ext4_iloc iloc
;
1864 down_read(&EXT4_I(inode
)->xattr_sem
);
1865 if (!ext4_has_inline_data(inode
))
1868 error
= ext4_get_inode_loc(inode
, &iloc
);
1872 addr
= (__u64
)iloc
.bh
->b_blocknr
<< inode
->i_sb
->s_blocksize_bits
;
1873 addr
+= (char *)ext4_raw_inode(&iloc
) - iloc
.bh
->b_data
;
1874 addr
+= offsetof(struct ext4_inode
, i_block
);
1880 iomap
->length
= min_t(loff_t
, ext4_get_inline_size(inode
),
1881 i_size_read(inode
));
1882 iomap
->type
= IOMAP_INLINE
;
1886 up_read(&EXT4_I(inode
)->xattr_sem
);
1890 int ext4_inline_data_truncate(struct inode
*inode
, int *has_inline
)
1893 int inline_size
, value_len
, needed_blocks
, no_expand
, err
= 0;
1896 struct ext4_xattr_ibody_find is
= {
1897 .s
= { .not_found
= -ENODATA
, },
1899 struct ext4_xattr_info i
= {
1900 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
1901 .name
= EXT4_XATTR_SYSTEM_DATA
,
1905 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1906 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, needed_blocks
);
1908 return PTR_ERR(handle
);
1910 ext4_write_lock_xattr(inode
, &no_expand
);
1911 if (!ext4_has_inline_data(inode
)) {
1912 ext4_write_unlock_xattr(inode
, &no_expand
);
1914 ext4_journal_stop(handle
);
1918 if ((err
= ext4_orphan_add(handle
, inode
)) != 0)
1921 if ((err
= ext4_get_inode_loc(inode
, &is
.iloc
)) != 0)
1924 down_write(&EXT4_I(inode
)->i_data_sem
);
1925 i_size
= inode
->i_size
;
1926 inline_size
= ext4_get_inline_size(inode
);
1927 EXT4_I(inode
)->i_disksize
= i_size
;
1929 if (i_size
< inline_size
) {
1931 * if there's inline data to truncate and this file was
1932 * converted to extents after that inline data was written,
1933 * the extent status cache must be cleared to avoid leaving
1934 * behind stale delayed allocated extent entries
1936 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
)) {
1938 err
= ext4_es_remove_extent(inode
, 0, EXT_MAX_BLOCKS
);
1939 if (err
== -ENOMEM
) {
1941 congestion_wait(BLK_RW_ASYNC
, HZ
/50);
1948 /* Clear the content in the xattr space. */
1949 if (inline_size
> EXT4_MIN_INLINE_DATA_SIZE
) {
1950 if ((err
= ext4_xattr_ibody_find(inode
, &i
, &is
)) != 0)
1953 BUG_ON(is
.s
.not_found
);
1955 value_len
= le32_to_cpu(is
.s
.here
->e_value_size
);
1956 value
= kmalloc(value_len
, GFP_NOFS
);
1962 err
= ext4_xattr_ibody_get(inode
, i
.name_index
,
1963 i
.name
, value
, value_len
);
1968 i
.value_len
= i_size
> EXT4_MIN_INLINE_DATA_SIZE
?
1969 i_size
- EXT4_MIN_INLINE_DATA_SIZE
: 0;
1970 err
= ext4_xattr_ibody_set(handle
, inode
, &i
, &is
);
1975 /* Clear the content within i_blocks. */
1976 if (i_size
< EXT4_MIN_INLINE_DATA_SIZE
) {
1977 void *p
= (void *) ext4_raw_inode(&is
.iloc
)->i_block
;
1978 memset(p
+ i_size
, 0,
1979 EXT4_MIN_INLINE_DATA_SIZE
- i_size
);
1982 EXT4_I(inode
)->i_inline_size
= i_size
<
1983 EXT4_MIN_INLINE_DATA_SIZE
?
1984 EXT4_MIN_INLINE_DATA_SIZE
: i_size
;
1988 up_write(&EXT4_I(inode
)->i_data_sem
);
1991 ext4_write_unlock_xattr(inode
, &no_expand
);
1994 ext4_orphan_del(handle
, inode
);
1997 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1998 err
= ext4_mark_inode_dirty(handle
, inode
);
2000 ext4_handle_sync(handle
);
2002 ext4_journal_stop(handle
);
2006 int ext4_convert_inline_data(struct inode
*inode
)
2008 int error
, needed_blocks
, no_expand
;
2010 struct ext4_iloc iloc
;
2012 if (!ext4_has_inline_data(inode
)) {
2013 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
2017 needed_blocks
= ext4_writepage_trans_blocks(inode
);
2020 error
= ext4_get_inode_loc(inode
, &iloc
);
2024 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
2025 if (IS_ERR(handle
)) {
2026 error
= PTR_ERR(handle
);
2030 ext4_write_lock_xattr(inode
, &no_expand
);
2031 if (ext4_has_inline_data(inode
))
2032 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
2033 ext4_write_unlock_xattr(inode
, &no_expand
);
2034 ext4_journal_stop(handle
);