2 * Copyright (c) 2012 Taobao.
3 * Written by Tao Ma <boyu.mt@taobao.com>
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.
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.
15 #include <linux/fiemap.h>
17 #include "ext4_jbd2.h"
22 #define EXT4_XATTR_SYSTEM_DATA "data"
23 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS))
24 #define EXT4_INLINE_DOTDOT_OFFSET 2
25 #define EXT4_INLINE_DOTDOT_SIZE 4
27 static int ext4_get_inline_size(struct inode
*inode
)
29 if (EXT4_I(inode
)->i_inline_off
)
30 return EXT4_I(inode
)->i_inline_size
;
35 static int get_max_inline_xattr_value_size(struct inode
*inode
,
36 struct ext4_iloc
*iloc
)
38 struct ext4_xattr_ibody_header
*header
;
39 struct ext4_xattr_entry
*entry
;
40 struct ext4_inode
*raw_inode
;
43 min_offs
= EXT4_SB(inode
->i_sb
)->s_inode_size
-
44 EXT4_GOOD_OLD_INODE_SIZE
-
45 EXT4_I(inode
)->i_extra_isize
-
46 sizeof(struct ext4_xattr_ibody_header
);
49 * We need to subtract another sizeof(__u32) since an in-inode xattr
50 * needs an empty 4 bytes to indicate the gap between the xattr entry
51 * and the name/value pair.
53 if (!ext4_test_inode_state(inode
, EXT4_STATE_XATTR
))
54 return EXT4_XATTR_SIZE(min_offs
-
55 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
)) -
56 EXT4_XATTR_ROUND
- sizeof(__u32
));
58 raw_inode
= ext4_raw_inode(iloc
);
59 header
= IHDR(inode
, raw_inode
);
60 entry
= IFIRST(header
);
62 /* Compute min_offs. */
63 for (; !IS_LAST_ENTRY(entry
); entry
= EXT4_XATTR_NEXT(entry
)) {
64 if (!entry
->e_value_block
&& entry
->e_value_size
) {
65 size_t offs
= le16_to_cpu(entry
->e_value_offs
);
71 ((void *)entry
- (void *)IFIRST(header
)) - sizeof(__u32
);
73 if (EXT4_I(inode
)->i_inline_off
) {
74 entry
= (struct ext4_xattr_entry
*)
75 ((void *)raw_inode
+ EXT4_I(inode
)->i_inline_off
);
77 free
+= EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
));
81 free
-= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
));
83 if (free
> EXT4_XATTR_ROUND
)
84 free
= EXT4_XATTR_SIZE(free
- EXT4_XATTR_ROUND
);
93 * Get the maximum size we now can store in an inode.
94 * If we can't find the space for a xattr entry, don't use the space
95 * of the extents since we have no space to indicate the inline data.
97 int ext4_get_max_inline_size(struct inode
*inode
)
99 int error
, max_inline_size
;
100 struct ext4_iloc iloc
;
102 if (EXT4_I(inode
)->i_extra_isize
== 0)
105 error
= ext4_get_inode_loc(inode
, &iloc
);
107 ext4_error_inode(inode
, __func__
, __LINE__
, 0,
108 "can't get inode location %lu",
113 down_read(&EXT4_I(inode
)->xattr_sem
);
114 max_inline_size
= get_max_inline_xattr_value_size(inode
, &iloc
);
115 up_read(&EXT4_I(inode
)->xattr_sem
);
119 if (!max_inline_size
)
122 return max_inline_size
+ EXT4_MIN_INLINE_DATA_SIZE
;
126 * this function does not take xattr_sem, which is OK because it is
127 * currently only used in a code path coming form ext4_iget, before
128 * the new inode has been unlocked
130 int ext4_find_inline_data_nolock(struct inode
*inode
)
132 struct ext4_xattr_ibody_find is
= {
133 .s
= { .not_found
= -ENODATA
, },
135 struct ext4_xattr_info i
= {
136 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
137 .name
= EXT4_XATTR_SYSTEM_DATA
,
141 if (EXT4_I(inode
)->i_extra_isize
== 0)
144 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
148 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
152 if (!is
.s
.not_found
) {
153 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
154 (void *)ext4_raw_inode(&is
.iloc
));
155 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
156 le32_to_cpu(is
.s
.here
->e_value_size
);
157 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
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 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 * Propagate changes to inode->i_flags as well - e.g. S_DAX may
309 ext4_set_inode_flags(inode
);
311 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
318 static int ext4_update_inline_data(handle_t
*handle
, struct inode
*inode
,
323 struct ext4_xattr_ibody_find is
= {
324 .s
= { .not_found
= -ENODATA
, },
326 struct ext4_xattr_info i
= {
327 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
328 .name
= EXT4_XATTR_SYSTEM_DATA
,
331 /* If the old space is ok, write the data directly. */
332 if (len
<= EXT4_I(inode
)->i_inline_size
)
335 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
339 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
343 BUG_ON(is
.s
.not_found
);
345 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
346 value
= kzalloc(len
, GFP_NOFS
);
352 error
= ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
354 if (error
== -ENODATA
)
357 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
358 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
362 /* Update the xttr entry. */
366 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
370 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
371 (void *)ext4_raw_inode(&is
.iloc
));
372 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
373 le32_to_cpu(is
.s
.here
->e_value_size
);
374 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
376 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
384 static int ext4_prepare_inline_data(handle_t
*handle
, struct inode
*inode
,
387 int ret
, size
, no_expand
;
388 struct ext4_inode_info
*ei
= EXT4_I(inode
);
390 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
))
393 size
= ext4_get_max_inline_size(inode
);
397 ext4_write_lock_xattr(inode
, &no_expand
);
399 if (ei
->i_inline_off
)
400 ret
= ext4_update_inline_data(handle
, inode
, len
);
402 ret
= ext4_create_inline_data(handle
, inode
, len
);
404 ext4_write_unlock_xattr(inode
, &no_expand
);
408 static int ext4_destroy_inline_data_nolock(handle_t
*handle
,
411 struct ext4_inode_info
*ei
= EXT4_I(inode
);
412 struct ext4_xattr_ibody_find is
= {
413 .s
= { .not_found
= 0, },
415 struct ext4_xattr_info i
= {
416 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
417 .name
= EXT4_XATTR_SYSTEM_DATA
,
423 if (!ei
->i_inline_off
)
426 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
430 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
434 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
435 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
439 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
443 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
444 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
);
455 * Propagate changes to inode->i_flags as well - e.g. S_DAX may
458 ext4_set_inode_flags(inode
);
461 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
463 EXT4_I(inode
)->i_inline_off
= 0;
464 EXT4_I(inode
)->i_inline_size
= 0;
465 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
468 if (error
== -ENODATA
)
473 static int ext4_read_inline_page(struct inode
*inode
, struct page
*page
)
478 struct ext4_iloc iloc
;
480 BUG_ON(!PageLocked(page
));
481 BUG_ON(!ext4_has_inline_data(inode
));
484 if (!EXT4_I(inode
)->i_inline_off
) {
485 ext4_warning(inode
->i_sb
, "inode %lu doesn't have inline data.",
490 ret
= ext4_get_inode_loc(inode
, &iloc
);
494 len
= min_t(size_t, ext4_get_inline_size(inode
), i_size_read(inode
));
495 kaddr
= kmap_atomic(page
);
496 ret
= ext4_read_inline_data(inode
, kaddr
, len
, &iloc
);
497 flush_dcache_page(page
);
498 kunmap_atomic(kaddr
);
499 zero_user_segment(page
, len
, PAGE_SIZE
);
500 SetPageUptodate(page
);
507 int ext4_readpage_inline(struct inode
*inode
, struct page
*page
)
511 down_read(&EXT4_I(inode
)->xattr_sem
);
512 if (!ext4_has_inline_data(inode
)) {
513 up_read(&EXT4_I(inode
)->xattr_sem
);
518 * Current inline data can only exist in the 1st page,
519 * So for all the other pages, just set them uptodate.
522 ret
= ext4_read_inline_page(inode
, page
);
523 else if (!PageUptodate(page
)) {
524 zero_user_segment(page
, 0, PAGE_SIZE
);
525 SetPageUptodate(page
);
528 up_read(&EXT4_I(inode
)->xattr_sem
);
531 return ret
>= 0 ? 0 : ret
;
534 static int ext4_convert_inline_data_to_extent(struct address_space
*mapping
,
538 int ret
, needed_blocks
, no_expand
;
539 handle_t
*handle
= NULL
;
540 int retries
= 0, sem_held
= 0;
541 struct page
*page
= NULL
;
543 struct ext4_iloc iloc
;
545 if (!ext4_has_inline_data(inode
)) {
547 * clear the flag so that no new write
548 * will trap here again.
550 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
554 needed_blocks
= ext4_writepage_trans_blocks(inode
);
556 ret
= ext4_get_inode_loc(inode
, &iloc
);
561 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
562 if (IS_ERR(handle
)) {
563 ret
= PTR_ERR(handle
);
568 /* We cannot recurse into the filesystem as the transaction is already
570 flags
|= AOP_FLAG_NOFS
;
572 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
578 ext4_write_lock_xattr(inode
, &no_expand
);
580 /* If some one has already done this for us, just exit. */
581 if (!ext4_has_inline_data(inode
)) {
587 to
= ext4_get_inline_size(inode
);
588 if (!PageUptodate(page
)) {
589 ret
= ext4_read_inline_page(inode
, page
);
594 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
598 if (ext4_should_dioread_nolock(inode
)) {
599 ret
= __block_write_begin(page
, from
, to
,
600 ext4_get_block_unwritten
);
602 ret
= __block_write_begin(page
, from
, to
, ext4_get_block
);
604 if (!ret
&& ext4_should_journal_data(inode
)) {
605 ret
= ext4_walk_page_buffers(handle
, page_buffers(page
),
607 do_journal_get_write_access
);
614 ext4_orphan_add(handle
, inode
);
615 ext4_write_unlock_xattr(inode
, &no_expand
);
617 ext4_journal_stop(handle
);
619 ext4_truncate_failed_write(inode
);
621 * If truncate failed early the inode might
622 * still be on the orphan list; we need to
623 * make sure the inode is removed from the
624 * orphan list in that case.
627 ext4_orphan_del(NULL
, inode
);
630 if (ret
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
634 block_commit_write(page
, from
, to
);
641 ext4_write_unlock_xattr(inode
, &no_expand
);
643 ext4_journal_stop(handle
);
649 * Try to write data in the inode.
650 * If the inode has inline data, check whether the new write can be
651 * in the inode also. If not, create the page the handle, move the data
652 * to the page make it update and let the later codes create extent for it.
654 int ext4_try_to_write_inline_data(struct address_space
*mapping
,
656 loff_t pos
, unsigned len
,
663 struct ext4_iloc iloc
;
665 if (pos
+ len
> ext4_get_max_inline_size(inode
))
668 ret
= ext4_get_inode_loc(inode
, &iloc
);
673 * The possible write could happen in the inode,
674 * so try to reserve the space in inode first.
676 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
677 if (IS_ERR(handle
)) {
678 ret
= PTR_ERR(handle
);
683 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
684 if (ret
&& ret
!= -ENOSPC
)
687 /* We don't have space in inline inode, so convert it to extent. */
688 if (ret
== -ENOSPC
) {
689 ext4_journal_stop(handle
);
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
);
720 up_read(&EXT4_I(inode
)->xattr_sem
);
723 ext4_journal_stop(handle
);
727 return ext4_convert_inline_data_to_extent(mapping
,
731 int ext4_write_inline_data_end(struct inode
*inode
, loff_t pos
, unsigned len
,
732 unsigned copied
, struct page
*page
)
736 struct ext4_iloc iloc
;
738 if (unlikely(copied
< len
)) {
739 if (!PageUptodate(page
)) {
745 ret
= ext4_get_inode_loc(inode
, &iloc
);
747 ext4_std_error(inode
->i_sb
, ret
);
752 ext4_write_lock_xattr(inode
, &no_expand
);
753 BUG_ON(!ext4_has_inline_data(inode
));
755 kaddr
= kmap_atomic(page
);
756 ext4_write_inline_data(inode
, &iloc
, kaddr
, pos
, len
);
757 kunmap_atomic(kaddr
);
758 SetPageUptodate(page
);
759 /* clear page dirty so that writepages wouldn't work for us. */
760 ClearPageDirty(page
);
762 ext4_write_unlock_xattr(inode
, &no_expand
);
769 ext4_journalled_write_inline_data(struct inode
*inode
,
775 struct ext4_iloc iloc
;
777 ret
= ext4_get_inode_loc(inode
, &iloc
);
779 ext4_std_error(inode
->i_sb
, ret
);
783 ext4_write_lock_xattr(inode
, &no_expand
);
784 kaddr
= kmap_atomic(page
);
785 ext4_write_inline_data(inode
, &iloc
, kaddr
, 0, len
);
786 kunmap_atomic(kaddr
);
787 ext4_write_unlock_xattr(inode
, &no_expand
);
793 * Try to make the page cache and handle ready for the inline data case.
794 * We can call this function in 2 cases:
795 * 1. The inode is created and the first write exceeds inline size. We can
796 * clear the inode state safely.
797 * 2. The inode has inline data, then we need to read the data, make it
798 * update and dirty so that ext4_da_writepages can handle it. We don't
799 * need to start the journal since the file's metatdata isn't changed now.
801 static int ext4_da_convert_inline_data_to_extent(struct address_space
*mapping
,
806 int ret
= 0, inline_size
;
809 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
813 down_read(&EXT4_I(inode
)->xattr_sem
);
814 if (!ext4_has_inline_data(inode
)) {
815 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
819 inline_size
= ext4_get_inline_size(inode
);
821 if (!PageUptodate(page
)) {
822 ret
= ext4_read_inline_page(inode
, page
);
827 ret
= __block_write_begin(page
, 0, inline_size
,
828 ext4_da_get_block_prep
);
830 up_read(&EXT4_I(inode
)->xattr_sem
);
833 ext4_truncate_failed_write(inode
);
838 SetPageUptodate(page
);
839 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
840 *fsdata
= (void *)CONVERT_INLINE_DATA
;
843 up_read(&EXT4_I(inode
)->xattr_sem
);
852 * Prepare the write for the inline data.
853 * If the the data can be written into the inode, we just read
854 * the page and make it uptodate, and start the journal.
855 * Otherwise read the page, makes it dirty so that it can be
856 * handle in writepages(the i_disksize update is left to the
857 * normal ext4_da_write_end).
859 int ext4_da_write_inline_data_begin(struct address_space
*mapping
,
861 loff_t pos
, unsigned len
,
866 int ret
, inline_size
;
869 struct ext4_iloc iloc
;
872 ret
= ext4_get_inode_loc(inode
, &iloc
);
877 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
878 if (IS_ERR(handle
)) {
879 ret
= PTR_ERR(handle
);
883 inline_size
= ext4_get_max_inline_size(inode
);
886 if (inline_size
>= pos
+ len
) {
887 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
888 if (ret
&& ret
!= -ENOSPC
)
893 * We cannot recurse into the filesystem as the transaction
894 * is already started.
896 flags
|= AOP_FLAG_NOFS
;
898 if (ret
== -ENOSPC
) {
899 ret
= ext4_da_convert_inline_data_to_extent(mapping
,
903 ext4_journal_stop(handle
);
904 if (ret
== -ENOSPC
&&
905 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
911 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
917 down_read(&EXT4_I(inode
)->xattr_sem
);
918 if (!ext4_has_inline_data(inode
)) {
920 goto out_release_page
;
923 if (!PageUptodate(page
)) {
924 ret
= ext4_read_inline_page(inode
, page
);
926 goto out_release_page
;
929 up_read(&EXT4_I(inode
)->xattr_sem
);
934 up_read(&EXT4_I(inode
)->xattr_sem
);
938 ext4_journal_stop(handle
);
944 int ext4_da_write_inline_data_end(struct inode
*inode
, loff_t pos
,
945 unsigned len
, unsigned copied
,
948 int i_size_changed
= 0;
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
);
974 * Don't mark the inode dirty under page lock. First, it unnecessarily
975 * makes the holding time of page lock longer. Second, it forces lock
976 * ordering of page lock and transaction start for journaling
980 mark_inode_dirty(inode
);
985 #ifdef INLINE_DIR_DEBUG
986 void ext4_show_inline_dir(struct inode
*dir
, struct buffer_head
*bh
,
987 void *inline_start
, int inline_size
)
990 unsigned short de_len
;
991 struct ext4_dir_entry_2
*de
= inline_start
;
992 void *dlimit
= inline_start
+ inline_size
;
994 trace_printk("inode %lu\n", dir
->i_ino
);
996 while ((void *)de
< dlimit
) {
997 de_len
= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
998 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
999 offset
, de_len
, de
->name_len
, de
->name
,
1000 de
->name_len
, le32_to_cpu(de
->inode
));
1001 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
1002 inline_start
, inline_size
, offset
))
1006 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
1010 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
1014 * Add a new entry into a inline dir.
1015 * It will return -ENOSPC if no space is available, and -EIO
1016 * and -EEXIST if directory entry already exists.
1018 static int ext4_add_dirent_to_inline(handle_t
*handle
,
1019 struct ext4_filename
*fname
,
1021 struct inode
*inode
,
1022 struct ext4_iloc
*iloc
,
1023 void *inline_start
, int inline_size
)
1026 struct ext4_dir_entry_2
*de
;
1028 err
= ext4_find_dest_de(dir
, inode
, iloc
->bh
, inline_start
,
1029 inline_size
, fname
, &de
);
1033 BUFFER_TRACE(iloc
->bh
, "get_write_access");
1034 err
= ext4_journal_get_write_access(handle
, iloc
->bh
);
1037 ext4_insert_dentry(dir
, inode
, de
, inline_size
, fname
);
1039 ext4_show_inline_dir(dir
, iloc
->bh
, inline_start
, inline_size
);
1042 * XXX shouldn't update any times until successful
1043 * completion of syscall, but too many callers depend
1046 * XXX similarly, too many callers depend on
1047 * ext4_new_inode() setting the times, but error
1048 * recovery deletes the inode, so the worst that can
1049 * happen is that the times are slightly out of date
1050 * and/or different from the directory change time.
1052 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1053 ext4_update_dx_flag(dir
);
1058 static void *ext4_get_inline_xattr_pos(struct inode
*inode
,
1059 struct ext4_iloc
*iloc
)
1061 struct ext4_xattr_entry
*entry
;
1062 struct ext4_xattr_ibody_header
*header
;
1064 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
1066 header
= IHDR(inode
, ext4_raw_inode(iloc
));
1067 entry
= (struct ext4_xattr_entry
*)((void *)ext4_raw_inode(iloc
) +
1068 EXT4_I(inode
)->i_inline_off
);
1070 return (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
);
1073 /* Set the final de to cover the whole block. */
1074 static void ext4_update_final_de(void *de_buf
, int old_size
, int new_size
)
1076 struct ext4_dir_entry_2
*de
, *prev_de
;
1080 de
= (struct ext4_dir_entry_2
*)de_buf
;
1082 limit
= de_buf
+ old_size
;
1085 de_len
= ext4_rec_len_from_disk(de
->rec_len
, old_size
);
1087 de
= (struct ext4_dir_entry_2
*)de_buf
;
1088 } while (de_buf
< limit
);
1090 prev_de
->rec_len
= ext4_rec_len_to_disk(de_len
+ new_size
-
1091 old_size
, new_size
);
1093 /* this is just created, so create an empty entry. */
1095 de
->rec_len
= ext4_rec_len_to_disk(new_size
, new_size
);
1099 static int ext4_update_inline_dir(handle_t
*handle
, struct inode
*dir
,
1100 struct ext4_iloc
*iloc
)
1103 int old_size
= EXT4_I(dir
)->i_inline_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1104 int new_size
= get_max_inline_xattr_value_size(dir
, iloc
);
1106 if (new_size
- old_size
<= EXT4_DIR_REC_LEN(1))
1109 ret
= ext4_update_inline_data(handle
, dir
,
1110 new_size
+ EXT4_MIN_INLINE_DATA_SIZE
);
1114 ext4_update_final_de(ext4_get_inline_xattr_pos(dir
, iloc
), old_size
,
1115 EXT4_I(dir
)->i_inline_size
-
1116 EXT4_MIN_INLINE_DATA_SIZE
);
1117 dir
->i_size
= EXT4_I(dir
)->i_disksize
= EXT4_I(dir
)->i_inline_size
;
1121 static void ext4_restore_inline_data(handle_t
*handle
, struct inode
*inode
,
1122 struct ext4_iloc
*iloc
,
1123 void *buf
, int inline_size
)
1125 ext4_create_inline_data(handle
, inode
, inline_size
);
1126 ext4_write_inline_data(inode
, iloc
, buf
, 0, inline_size
);
1127 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1130 static int ext4_finish_convert_inline_dir(handle_t
*handle
,
1131 struct inode
*inode
,
1132 struct buffer_head
*dir_block
,
1136 int err
, csum_size
= 0, header_size
= 0;
1137 struct ext4_dir_entry_2
*de
;
1138 struct ext4_dir_entry_tail
*t
;
1139 void *target
= dir_block
->b_data
;
1142 * First create "." and ".." and then copy the dir information
1143 * back to the block.
1145 de
= (struct ext4_dir_entry_2
*)target
;
1146 de
= ext4_init_dot_dotdot(inode
, de
,
1147 inode
->i_sb
->s_blocksize
, csum_size
,
1148 le32_to_cpu(((struct ext4_dir_entry_2
*)buf
)->inode
), 1);
1149 header_size
= (void *)de
- target
;
1151 memcpy((void *)de
, buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1152 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1154 if (ext4_has_metadata_csum(inode
->i_sb
))
1155 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1157 inode
->i_size
= inode
->i_sb
->s_blocksize
;
1158 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
1159 EXT4_I(inode
)->i_disksize
= inode
->i_sb
->s_blocksize
;
1160 ext4_update_final_de(dir_block
->b_data
,
1161 inline_size
- EXT4_INLINE_DOTDOT_SIZE
+ header_size
,
1162 inode
->i_sb
->s_blocksize
- csum_size
);
1165 t
= EXT4_DIRENT_TAIL(dir_block
->b_data
,
1166 inode
->i_sb
->s_blocksize
);
1167 initialize_dirent_tail(t
, inode
->i_sb
->s_blocksize
);
1169 set_buffer_uptodate(dir_block
);
1170 err
= ext4_handle_dirty_dirent_node(handle
, inode
, dir_block
);
1173 set_buffer_verified(dir_block
);
1178 static int ext4_convert_inline_data_nolock(handle_t
*handle
,
1179 struct inode
*inode
,
1180 struct ext4_iloc
*iloc
)
1184 struct buffer_head
*data_bh
= NULL
;
1185 struct ext4_map_blocks map
;
1188 inline_size
= ext4_get_inline_size(inode
);
1189 buf
= kmalloc(inline_size
, GFP_NOFS
);
1195 error
= ext4_read_inline_data(inode
, buf
, inline_size
, iloc
);
1200 * Make sure the inline directory entries pass checks before we try to
1201 * convert them, so that we avoid touching stuff that needs fsck.
1203 if (S_ISDIR(inode
->i_mode
)) {
1204 error
= ext4_check_all_de(inode
, iloc
->bh
,
1205 buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1206 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1211 error
= ext4_destroy_inline_data_nolock(handle
, inode
);
1218 error
= ext4_map_blocks(handle
, inode
, &map
, EXT4_GET_BLOCKS_CREATE
);
1221 if (!(map
.m_flags
& EXT4_MAP_MAPPED
)) {
1226 data_bh
= sb_getblk(inode
->i_sb
, map
.m_pblk
);
1232 lock_buffer(data_bh
);
1233 error
= ext4_journal_get_create_access(handle
, data_bh
);
1235 unlock_buffer(data_bh
);
1239 memset(data_bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1241 if (!S_ISDIR(inode
->i_mode
)) {
1242 memcpy(data_bh
->b_data
, buf
, inline_size
);
1243 set_buffer_uptodate(data_bh
);
1244 error
= ext4_handle_dirty_metadata(handle
,
1247 error
= ext4_finish_convert_inline_dir(handle
, inode
, data_bh
,
1251 unlock_buffer(data_bh
);
1254 ext4_restore_inline_data(handle
, inode
, iloc
, buf
, inline_size
);
1263 * Try to add the new entry to the inline data.
1264 * If succeeds, return 0. If not, extended the inline dir and copied data to
1265 * the new created block.
1267 int ext4_try_add_inline_entry(handle_t
*handle
, struct ext4_filename
*fname
,
1268 struct inode
*dir
, struct inode
*inode
)
1270 int ret
, inline_size
, no_expand
;
1272 struct ext4_iloc iloc
;
1274 ret
= ext4_get_inode_loc(dir
, &iloc
);
1278 ext4_write_lock_xattr(dir
, &no_expand
);
1279 if (!ext4_has_inline_data(dir
))
1282 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1283 EXT4_INLINE_DOTDOT_SIZE
;
1284 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1286 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
, inode
, &iloc
,
1287 inline_start
, inline_size
);
1291 /* check whether it can be inserted to inline xattr space. */
1292 inline_size
= EXT4_I(dir
)->i_inline_size
-
1293 EXT4_MIN_INLINE_DATA_SIZE
;
1295 /* Try to use the xattr space.*/
1296 ret
= ext4_update_inline_dir(handle
, dir
, &iloc
);
1297 if (ret
&& ret
!= -ENOSPC
)
1300 inline_size
= EXT4_I(dir
)->i_inline_size
-
1301 EXT4_MIN_INLINE_DATA_SIZE
;
1305 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1307 ret
= ext4_add_dirent_to_inline(handle
, fname
, dir
,
1308 inode
, &iloc
, inline_start
,
1316 * The inline space is filled up, so create a new block for it.
1317 * As the extent tree will be created, we have to save the inline
1320 ret
= ext4_convert_inline_data_nolock(handle
, dir
, &iloc
);
1323 ext4_write_unlock_xattr(dir
, &no_expand
);
1324 ext4_mark_inode_dirty(handle
, dir
);
1330 * This function fills a red-black tree with information from an
1331 * inlined dir. It returns the number directory entries loaded
1332 * into the tree. If there is an error it is returned in err.
1334 int htree_inlinedir_to_tree(struct file
*dir_file
,
1335 struct inode
*dir
, ext4_lblk_t block
,
1336 struct dx_hash_info
*hinfo
,
1337 __u32 start_hash
, __u32 start_minor_hash
,
1338 int *has_inline_data
)
1340 int err
= 0, count
= 0;
1341 unsigned int parent_ino
;
1343 struct ext4_dir_entry_2
*de
;
1344 struct inode
*inode
= file_inode(dir_file
);
1345 int ret
, inline_size
= 0;
1346 struct ext4_iloc iloc
;
1347 void *dir_buf
= NULL
;
1348 struct ext4_dir_entry_2 fake
;
1349 struct fscrypt_str tmp_str
;
1351 ret
= ext4_get_inode_loc(inode
, &iloc
);
1355 down_read(&EXT4_I(inode
)->xattr_sem
);
1356 if (!ext4_has_inline_data(inode
)) {
1357 up_read(&EXT4_I(inode
)->xattr_sem
);
1358 *has_inline_data
= 0;
1362 inline_size
= ext4_get_inline_size(inode
);
1363 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1366 up_read(&EXT4_I(inode
)->xattr_sem
);
1370 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1371 up_read(&EXT4_I(inode
)->xattr_sem
);
1376 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1377 while (pos
< inline_size
) {
1379 * As inlined dir doesn't store any information about '.' and
1380 * only the inode number of '..' is stored, we have to handle
1384 fake
.inode
= cpu_to_le32(inode
->i_ino
);
1386 strcpy(fake
.name
, ".");
1387 fake
.rec_len
= ext4_rec_len_to_disk(
1388 EXT4_DIR_REC_LEN(fake
.name_len
),
1390 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1392 pos
= EXT4_INLINE_DOTDOT_OFFSET
;
1393 } else if (pos
== EXT4_INLINE_DOTDOT_OFFSET
) {
1394 fake
.inode
= cpu_to_le32(parent_ino
);
1396 strcpy(fake
.name
, "..");
1397 fake
.rec_len
= ext4_rec_len_to_disk(
1398 EXT4_DIR_REC_LEN(fake
.name_len
),
1400 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1402 pos
= EXT4_INLINE_DOTDOT_SIZE
;
1404 de
= (struct ext4_dir_entry_2
*)(dir_buf
+ pos
);
1405 pos
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1406 if (ext4_check_dir_entry(inode
, dir_file
, de
,
1408 inline_size
, pos
)) {
1414 ext4fs_dirhash(de
->name
, de
->name_len
, hinfo
);
1415 if ((hinfo
->hash
< start_hash
) ||
1416 ((hinfo
->hash
== start_hash
) &&
1417 (hinfo
->minor_hash
< start_minor_hash
)))
1421 tmp_str
.name
= de
->name
;
1422 tmp_str
.len
= de
->name_len
;
1423 err
= ext4_htree_store_dirent(dir_file
, hinfo
->hash
,
1424 hinfo
->minor_hash
, de
, &tmp_str
);
1439 * So this function is called when the volume is mkfsed with
1440 * dir_index disabled. In order to keep f_pos persistent
1441 * after we convert from an inlined dir to a blocked based,
1442 * we just pretend that we are a normal dir and return the
1443 * offset as if '.' and '..' really take place.
1446 int ext4_read_inline_dir(struct file
*file
,
1447 struct dir_context
*ctx
,
1448 int *has_inline_data
)
1450 unsigned int offset
, parent_ino
;
1452 struct ext4_dir_entry_2
*de
;
1453 struct super_block
*sb
;
1454 struct inode
*inode
= file_inode(file
);
1455 int ret
, inline_size
= 0;
1456 struct ext4_iloc iloc
;
1457 void *dir_buf
= NULL
;
1458 int dotdot_offset
, dotdot_size
, extra_offset
, extra_size
;
1460 ret
= ext4_get_inode_loc(inode
, &iloc
);
1464 down_read(&EXT4_I(inode
)->xattr_sem
);
1465 if (!ext4_has_inline_data(inode
)) {
1466 up_read(&EXT4_I(inode
)->xattr_sem
);
1467 *has_inline_data
= 0;
1471 inline_size
= ext4_get_inline_size(inode
);
1472 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1475 up_read(&EXT4_I(inode
)->xattr_sem
);
1479 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1480 up_read(&EXT4_I(inode
)->xattr_sem
);
1486 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1490 * dotdot_offset and dotdot_size is the real offset and
1491 * size for ".." and "." if the dir is block based while
1492 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1493 * So we will use extra_offset and extra_size to indicate them
1494 * during the inline dir iteration.
1496 dotdot_offset
= EXT4_DIR_REC_LEN(1);
1497 dotdot_size
= dotdot_offset
+ EXT4_DIR_REC_LEN(2);
1498 extra_offset
= dotdot_size
- EXT4_INLINE_DOTDOT_SIZE
;
1499 extra_size
= extra_offset
+ inline_size
;
1502 * If the version has changed since the last call to
1503 * readdir(2), then we might be pointing to an invalid
1504 * dirent right now. Scan from the start of the inline
1507 if (file
->f_version
!= inode
->i_version
) {
1508 for (i
= 0; i
< extra_size
&& i
< offset
;) {
1510 * "." is with offset 0 and
1511 * ".." is dotdot_offset.
1516 } else if (i
== dotdot_offset
) {
1520 /* for other entry, the real offset in
1521 * the buf has to be tuned accordingly.
1523 de
= (struct ext4_dir_entry_2
*)
1524 (dir_buf
+ i
- extra_offset
);
1525 /* It's too expensive to do a full
1526 * dirent test each time round this
1527 * loop, but we do have to test at
1528 * least that it is non-zero. A
1529 * failure will be detected in the
1530 * dirent test below. */
1531 if (ext4_rec_len_from_disk(de
->rec_len
, extra_size
)
1532 < EXT4_DIR_REC_LEN(1))
1534 i
+= ext4_rec_len_from_disk(de
->rec_len
,
1539 file
->f_version
= inode
->i_version
;
1542 while (ctx
->pos
< extra_size
) {
1543 if (ctx
->pos
== 0) {
1544 if (!dir_emit(ctx
, ".", 1, inode
->i_ino
, DT_DIR
))
1546 ctx
->pos
= dotdot_offset
;
1550 if (ctx
->pos
== dotdot_offset
) {
1551 if (!dir_emit(ctx
, "..", 2, parent_ino
, DT_DIR
))
1553 ctx
->pos
= dotdot_size
;
1557 de
= (struct ext4_dir_entry_2
*)
1558 (dir_buf
+ ctx
->pos
- extra_offset
);
1559 if (ext4_check_dir_entry(inode
, file
, de
, iloc
.bh
, dir_buf
,
1560 extra_size
, ctx
->pos
))
1562 if (le32_to_cpu(de
->inode
)) {
1563 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1564 le32_to_cpu(de
->inode
),
1565 get_dtype(sb
, de
->file_type
)))
1568 ctx
->pos
+= ext4_rec_len_from_disk(de
->rec_len
, extra_size
);
1576 struct buffer_head
*ext4_get_first_inline_block(struct inode
*inode
,
1577 struct ext4_dir_entry_2
**parent_de
,
1580 struct ext4_iloc iloc
;
1582 *retval
= ext4_get_inode_loc(inode
, &iloc
);
1586 *parent_de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1592 * Try to create the inline data for the new dir.
1593 * If it succeeds, return 0, otherwise return the error.
1594 * In case of ENOSPC, the caller should create the normal disk layout dir.
1596 int ext4_try_create_inline_dir(handle_t
*handle
, struct inode
*parent
,
1597 struct inode
*inode
)
1599 int ret
, inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1600 struct ext4_iloc iloc
;
1601 struct ext4_dir_entry_2
*de
;
1603 ret
= ext4_get_inode_loc(inode
, &iloc
);
1607 ret
= ext4_prepare_inline_data(handle
, inode
, inline_size
);
1612 * For inline dir, we only save the inode information for the ".."
1613 * and create a fake dentry to cover the left space.
1615 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1616 de
->inode
= cpu_to_le32(parent
->i_ino
);
1617 de
= (struct ext4_dir_entry_2
*)((void *)de
+ EXT4_INLINE_DOTDOT_SIZE
);
1619 de
->rec_len
= ext4_rec_len_to_disk(
1620 inline_size
- EXT4_INLINE_DOTDOT_SIZE
,
1622 set_nlink(inode
, 2);
1623 inode
->i_size
= EXT4_I(inode
)->i_disksize
= inline_size
;
1629 struct buffer_head
*ext4_find_inline_entry(struct inode
*dir
,
1630 struct ext4_filename
*fname
,
1631 const struct qstr
*d_name
,
1632 struct ext4_dir_entry_2
**res_dir
,
1633 int *has_inline_data
)
1636 struct ext4_iloc iloc
;
1640 if (ext4_get_inode_loc(dir
, &iloc
))
1643 down_read(&EXT4_I(dir
)->xattr_sem
);
1644 if (!ext4_has_inline_data(dir
)) {
1645 *has_inline_data
= 0;
1649 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1650 EXT4_INLINE_DOTDOT_SIZE
;
1651 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1652 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1653 dir
, fname
, d_name
, 0, res_dir
);
1659 if (ext4_get_inline_size(dir
) == EXT4_MIN_INLINE_DATA_SIZE
)
1662 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1663 inline_size
= ext4_get_inline_size(dir
) - EXT4_MIN_INLINE_DATA_SIZE
;
1665 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1666 dir
, fname
, d_name
, 0, res_dir
);
1674 up_read(&EXT4_I(dir
)->xattr_sem
);
1678 int ext4_delete_inline_entry(handle_t
*handle
,
1680 struct ext4_dir_entry_2
*de_del
,
1681 struct buffer_head
*bh
,
1682 int *has_inline_data
)
1684 int err
, inline_size
, no_expand
;
1685 struct ext4_iloc iloc
;
1688 err
= ext4_get_inode_loc(dir
, &iloc
);
1692 ext4_write_lock_xattr(dir
, &no_expand
);
1693 if (!ext4_has_inline_data(dir
)) {
1694 *has_inline_data
= 0;
1698 if ((void *)de_del
- ((void *)ext4_raw_inode(&iloc
)->i_block
) <
1699 EXT4_MIN_INLINE_DATA_SIZE
) {
1700 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1701 EXT4_INLINE_DOTDOT_SIZE
;
1702 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
-
1703 EXT4_INLINE_DOTDOT_SIZE
;
1705 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1706 inline_size
= ext4_get_inline_size(dir
) -
1707 EXT4_MIN_INLINE_DATA_SIZE
;
1710 BUFFER_TRACE(bh
, "get_write_access");
1711 err
= ext4_journal_get_write_access(handle
, bh
);
1715 err
= ext4_generic_delete_entry(handle
, dir
, de_del
, bh
,
1716 inline_start
, inline_size
, 0);
1720 ext4_show_inline_dir(dir
, iloc
.bh
, inline_start
, inline_size
);
1722 ext4_write_unlock_xattr(dir
, &no_expand
);
1723 if (likely(err
== 0))
1724 err
= ext4_mark_inode_dirty(handle
, dir
);
1727 ext4_std_error(dir
->i_sb
, err
);
1732 * Get the inline dentry at offset.
1734 static inline struct ext4_dir_entry_2
*
1735 ext4_get_inline_entry(struct inode
*inode
,
1736 struct ext4_iloc
*iloc
,
1737 unsigned int offset
,
1738 void **inline_start
,
1743 BUG_ON(offset
> ext4_get_inline_size(inode
));
1745 if (offset
< EXT4_MIN_INLINE_DATA_SIZE
) {
1746 inline_pos
= (void *)ext4_raw_inode(iloc
)->i_block
;
1747 *inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1749 inline_pos
= ext4_get_inline_xattr_pos(inode
, iloc
);
1750 offset
-= EXT4_MIN_INLINE_DATA_SIZE
;
1751 *inline_size
= ext4_get_inline_size(inode
) -
1752 EXT4_MIN_INLINE_DATA_SIZE
;
1756 *inline_start
= inline_pos
;
1757 return (struct ext4_dir_entry_2
*)(inline_pos
+ offset
);
1760 bool empty_inline_dir(struct inode
*dir
, int *has_inline_data
)
1762 int err
, inline_size
;
1763 struct ext4_iloc iloc
;
1765 unsigned int offset
;
1766 struct ext4_dir_entry_2
*de
;
1769 err
= ext4_get_inode_loc(dir
, &iloc
);
1771 EXT4_ERROR_INODE(dir
, "error %d getting inode %lu block",
1776 down_read(&EXT4_I(dir
)->xattr_sem
);
1777 if (!ext4_has_inline_data(dir
)) {
1778 *has_inline_data
= 0;
1782 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1783 if (!le32_to_cpu(de
->inode
)) {
1784 ext4_warning(dir
->i_sb
,
1785 "bad inline directory (dir #%lu) - no `..'",
1791 offset
= EXT4_INLINE_DOTDOT_SIZE
;
1792 while (offset
< dir
->i_size
) {
1793 de
= ext4_get_inline_entry(dir
, &iloc
, offset
,
1794 &inline_pos
, &inline_size
);
1795 if (ext4_check_dir_entry(dir
, NULL
, de
,
1796 iloc
.bh
, inline_pos
,
1797 inline_size
, offset
)) {
1798 ext4_warning(dir
->i_sb
,
1799 "bad inline directory (dir #%lu) - "
1800 "inode %u, rec_len %u, name_len %d"
1802 dir
->i_ino
, le32_to_cpu(de
->inode
),
1803 le16_to_cpu(de
->rec_len
), de
->name_len
,
1808 if (le32_to_cpu(de
->inode
)) {
1812 offset
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1816 up_read(&EXT4_I(dir
)->xattr_sem
);
1821 int ext4_destroy_inline_data(handle_t
*handle
, struct inode
*inode
)
1825 ext4_write_lock_xattr(inode
, &no_expand
);
1826 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
1827 ext4_write_unlock_xattr(inode
, &no_expand
);
1832 int ext4_inline_data_fiemap(struct inode
*inode
,
1833 struct fiemap_extent_info
*fieinfo
,
1834 int *has_inline
, __u64 start
, __u64 len
)
1838 __u32 flags
= FIEMAP_EXTENT_DATA_INLINE
| FIEMAP_EXTENT_NOT_ALIGNED
|
1841 struct ext4_iloc iloc
;
1843 down_read(&EXT4_I(inode
)->xattr_sem
);
1844 if (!ext4_has_inline_data(inode
)) {
1848 inline_len
= min_t(size_t, ext4_get_inline_size(inode
),
1849 i_size_read(inode
));
1850 if (start
>= inline_len
)
1852 if (start
+ len
< inline_len
)
1853 inline_len
= start
+ len
;
1854 inline_len
-= start
;
1856 error
= ext4_get_inode_loc(inode
, &iloc
);
1860 physical
= (__u64
)iloc
.bh
->b_blocknr
<< inode
->i_sb
->s_blocksize_bits
;
1861 physical
+= (char *)ext4_raw_inode(&iloc
) - iloc
.bh
->b_data
;
1862 physical
+= offsetof(struct ext4_inode
, i_block
);
1865 error
= fiemap_fill_next_extent(fieinfo
, start
, physical
,
1869 up_read(&EXT4_I(inode
)->xattr_sem
);
1870 return (error
< 0 ? error
: 0);
1874 * Called during xattr set, and if we can sparse space 'needed',
1875 * just create the extent tree evict the data to the outer block.
1877 * We use jbd2 instead of page cache to move data to the 1st block
1878 * so that the whole transaction can be committed as a whole and
1879 * the data isn't lost because of the delayed page cache write.
1881 int ext4_try_to_evict_inline_data(handle_t
*handle
,
1882 struct inode
*inode
,
1886 struct ext4_xattr_entry
*entry
;
1887 struct ext4_inode
*raw_inode
;
1888 struct ext4_iloc iloc
;
1890 error
= ext4_get_inode_loc(inode
, &iloc
);
1894 raw_inode
= ext4_raw_inode(&iloc
);
1895 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
1896 EXT4_I(inode
)->i_inline_off
);
1897 if (EXT4_XATTR_LEN(entry
->e_name_len
) +
1898 EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
)) < needed
) {
1903 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
1909 int ext4_inline_data_truncate(struct inode
*inode
, int *has_inline
)
1912 int inline_size
, value_len
, needed_blocks
, no_expand
, err
= 0;
1915 struct ext4_xattr_ibody_find is
= {
1916 .s
= { .not_found
= -ENODATA
, },
1918 struct ext4_xattr_info i
= {
1919 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
1920 .name
= EXT4_XATTR_SYSTEM_DATA
,
1924 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1925 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, needed_blocks
);
1927 return PTR_ERR(handle
);
1929 ext4_write_lock_xattr(inode
, &no_expand
);
1930 if (!ext4_has_inline_data(inode
)) {
1932 ext4_journal_stop(handle
);
1936 if ((err
= ext4_orphan_add(handle
, inode
)) != 0)
1939 if ((err
= ext4_get_inode_loc(inode
, &is
.iloc
)) != 0)
1942 down_write(&EXT4_I(inode
)->i_data_sem
);
1943 i_size
= inode
->i_size
;
1944 inline_size
= ext4_get_inline_size(inode
);
1945 EXT4_I(inode
)->i_disksize
= i_size
;
1947 if (i_size
< inline_size
) {
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_inline_set(handle
, inode
,
1976 /* Clear the content within i_blocks. */
1977 if (i_size
< EXT4_MIN_INLINE_DATA_SIZE
) {
1978 void *p
= (void *) ext4_raw_inode(&is
.iloc
)->i_block
;
1979 memset(p
+ i_size
, 0,
1980 EXT4_MIN_INLINE_DATA_SIZE
- i_size
);
1983 EXT4_I(inode
)->i_inline_size
= i_size
<
1984 EXT4_MIN_INLINE_DATA_SIZE
?
1985 EXT4_MIN_INLINE_DATA_SIZE
: i_size
;
1989 up_write(&EXT4_I(inode
)->i_data_sem
);
1992 ext4_write_unlock_xattr(inode
, &no_expand
);
1995 ext4_orphan_del(handle
, inode
);
1998 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1999 err
= ext4_mark_inode_dirty(handle
, inode
);
2001 ext4_handle_sync(handle
);
2003 ext4_journal_stop(handle
);
2007 int ext4_convert_inline_data(struct inode
*inode
)
2009 int error
, needed_blocks
, no_expand
;
2011 struct ext4_iloc iloc
;
2013 if (!ext4_has_inline_data(inode
)) {
2014 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
2018 needed_blocks
= ext4_writepage_trans_blocks(inode
);
2021 error
= ext4_get_inode_loc(inode
, &iloc
);
2025 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
2026 if (IS_ERR(handle
)) {
2027 error
= PTR_ERR(handle
);
2031 ext4_write_lock_xattr(inode
, &no_expand
);
2032 if (ext4_has_inline_data(inode
))
2033 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
2034 ext4_write_unlock_xattr(inode
, &no_expand
);
2035 ext4_journal_stop(handle
);