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.
14 #include "ext4_jbd2.h"
18 #include <linux/fiemap.h>
20 #define EXT4_XATTR_SYSTEM_DATA "data"
21 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS))
22 #define EXT4_INLINE_DOTDOT_OFFSET 2
23 #define EXT4_INLINE_DOTDOT_SIZE 4
25 static int ext4_get_inline_size(struct inode
*inode
)
27 if (EXT4_I(inode
)->i_inline_off
)
28 return EXT4_I(inode
)->i_inline_size
;
33 static int get_max_inline_xattr_value_size(struct inode
*inode
,
34 struct ext4_iloc
*iloc
)
36 struct ext4_xattr_ibody_header
*header
;
37 struct ext4_xattr_entry
*entry
;
38 struct ext4_inode
*raw_inode
;
41 min_offs
= EXT4_SB(inode
->i_sb
)->s_inode_size
-
42 EXT4_GOOD_OLD_INODE_SIZE
-
43 EXT4_I(inode
)->i_extra_isize
-
44 sizeof(struct ext4_xattr_ibody_header
);
47 * We need to subtract another sizeof(__u32) since an in-inode xattr
48 * needs an empty 4 bytes to indicate the gap between the xattr entry
49 * and the name/value pair.
51 if (!ext4_test_inode_state(inode
, EXT4_STATE_XATTR
))
52 return EXT4_XATTR_SIZE(min_offs
-
53 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
)) -
54 EXT4_XATTR_ROUND
- sizeof(__u32
));
56 raw_inode
= ext4_raw_inode(iloc
);
57 header
= IHDR(inode
, raw_inode
);
58 entry
= IFIRST(header
);
60 /* Compute min_offs. */
61 for (; !IS_LAST_ENTRY(entry
); entry
= EXT4_XATTR_NEXT(entry
)) {
62 if (!entry
->e_value_block
&& entry
->e_value_size
) {
63 size_t offs
= le16_to_cpu(entry
->e_value_offs
);
69 ((void *)entry
- (void *)IFIRST(header
)) - sizeof(__u32
);
71 if (EXT4_I(inode
)->i_inline_off
) {
72 entry
= (struct ext4_xattr_entry
*)
73 ((void *)raw_inode
+ EXT4_I(inode
)->i_inline_off
);
75 free
+= EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
));
79 free
-= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
));
81 if (free
> EXT4_XATTR_ROUND
)
82 free
= EXT4_XATTR_SIZE(free
- EXT4_XATTR_ROUND
);
91 * Get the maximum size we now can store in an inode.
92 * If we can't find the space for a xattr entry, don't use the space
93 * of the extents since we have no space to indicate the inline data.
95 int ext4_get_max_inline_size(struct inode
*inode
)
97 int error
, max_inline_size
;
98 struct ext4_iloc iloc
;
100 if (EXT4_I(inode
)->i_extra_isize
== 0)
103 error
= ext4_get_inode_loc(inode
, &iloc
);
105 ext4_error_inode(inode
, __func__
, __LINE__
, 0,
106 "can't get inode location %lu",
111 down_read(&EXT4_I(inode
)->xattr_sem
);
112 max_inline_size
= get_max_inline_xattr_value_size(inode
, &iloc
);
113 up_read(&EXT4_I(inode
)->xattr_sem
);
117 if (!max_inline_size
)
120 return max_inline_size
+ EXT4_MIN_INLINE_DATA_SIZE
;
124 * this function does not take xattr_sem, which is OK because it is
125 * currently only used in a code path coming form ext4_iget, before
126 * the new inode has been unlocked
128 int ext4_find_inline_data_nolock(struct inode
*inode
)
130 struct ext4_xattr_ibody_find is
= {
131 .s
= { .not_found
= -ENODATA
, },
133 struct ext4_xattr_info i
= {
134 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
135 .name
= EXT4_XATTR_SYSTEM_DATA
,
139 if (EXT4_I(inode
)->i_extra_isize
== 0)
142 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
146 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
150 if (!is
.s
.not_found
) {
151 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
152 (void *)ext4_raw_inode(&is
.iloc
));
153 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
154 le32_to_cpu(is
.s
.here
->e_value_size
);
155 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
162 static int ext4_read_inline_data(struct inode
*inode
, void *buffer
,
164 struct ext4_iloc
*iloc
)
166 struct ext4_xattr_entry
*entry
;
167 struct ext4_xattr_ibody_header
*header
;
169 struct ext4_inode
*raw_inode
;
174 BUG_ON(len
> EXT4_I(inode
)->i_inline_size
);
176 cp_len
= len
< EXT4_MIN_INLINE_DATA_SIZE
?
177 len
: EXT4_MIN_INLINE_DATA_SIZE
;
179 raw_inode
= ext4_raw_inode(iloc
);
180 memcpy(buffer
, (void *)(raw_inode
->i_block
), cp_len
);
188 header
= IHDR(inode
, raw_inode
);
189 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
190 EXT4_I(inode
)->i_inline_off
);
191 len
= min_t(unsigned int, len
,
192 (unsigned int)le32_to_cpu(entry
->e_value_size
));
195 (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
), len
);
203 * write the buffer to the inline inode.
204 * If 'create' is set, we don't need to do the extra copy in the xattr
205 * value since it is already handled by ext4_xattr_ibody_inline_set.
206 * That saves us one memcpy.
208 static void ext4_write_inline_data(struct inode
*inode
, struct ext4_iloc
*iloc
,
209 void *buffer
, loff_t pos
, unsigned int len
)
211 struct ext4_xattr_entry
*entry
;
212 struct ext4_xattr_ibody_header
*header
;
213 struct ext4_inode
*raw_inode
;
216 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
217 BUG_ON(pos
+ len
> EXT4_I(inode
)->i_inline_size
);
219 raw_inode
= ext4_raw_inode(iloc
);
222 if (pos
< EXT4_MIN_INLINE_DATA_SIZE
) {
223 cp_len
= pos
+ len
> EXT4_MIN_INLINE_DATA_SIZE
?
224 EXT4_MIN_INLINE_DATA_SIZE
- pos
: len
;
225 memcpy((void *)raw_inode
->i_block
+ pos
, buffer
, cp_len
);
235 pos
-= EXT4_MIN_INLINE_DATA_SIZE
;
236 header
= IHDR(inode
, raw_inode
);
237 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
238 EXT4_I(inode
)->i_inline_off
);
240 memcpy((void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
) + pos
,
244 static int ext4_create_inline_data(handle_t
*handle
,
245 struct inode
*inode
, unsigned len
)
249 struct ext4_xattr_ibody_find is
= {
250 .s
= { .not_found
= -ENODATA
, },
252 struct ext4_xattr_info i
= {
253 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
254 .name
= EXT4_XATTR_SYSTEM_DATA
,
257 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
261 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
262 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
266 if (len
> EXT4_MIN_INLINE_DATA_SIZE
) {
267 value
= EXT4_ZERO_XATTR_VALUE
;
268 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
274 /* Insert the the xttr entry. */
278 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
282 BUG_ON(!is
.s
.not_found
);
284 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
286 if (error
== -ENOSPC
)
287 ext4_clear_inode_state(inode
,
288 EXT4_STATE_MAY_INLINE_DATA
);
292 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
293 0, EXT4_MIN_INLINE_DATA_SIZE
);
295 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
296 (void *)ext4_raw_inode(&is
.iloc
));
297 EXT4_I(inode
)->i_inline_size
= len
+ EXT4_MIN_INLINE_DATA_SIZE
;
298 ext4_clear_inode_flag(inode
, EXT4_INODE_EXTENTS
);
299 ext4_set_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
301 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
308 static int ext4_update_inline_data(handle_t
*handle
, struct inode
*inode
,
313 struct ext4_xattr_ibody_find is
= {
314 .s
= { .not_found
= -ENODATA
, },
316 struct ext4_xattr_info i
= {
317 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
318 .name
= EXT4_XATTR_SYSTEM_DATA
,
321 /* If the old space is ok, write the data directly. */
322 if (len
<= EXT4_I(inode
)->i_inline_size
)
325 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
329 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
333 BUG_ON(is
.s
.not_found
);
335 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
336 value
= kzalloc(len
, GFP_NOFS
);
340 error
= ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
342 if (error
== -ENODATA
)
345 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
346 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
350 /* Update the xttr entry. */
354 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
358 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
359 (void *)ext4_raw_inode(&is
.iloc
));
360 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
361 le32_to_cpu(is
.s
.here
->e_value_size
);
362 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
364 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
372 static int ext4_prepare_inline_data(handle_t
*handle
, struct inode
*inode
,
376 struct ext4_inode_info
*ei
= EXT4_I(inode
);
378 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
))
381 size
= ext4_get_max_inline_size(inode
);
385 down_write(&EXT4_I(inode
)->xattr_sem
);
387 if (ei
->i_inline_off
)
388 ret
= ext4_update_inline_data(handle
, inode
, len
);
390 ret
= ext4_create_inline_data(handle
, inode
, len
);
392 up_write(&EXT4_I(inode
)->xattr_sem
);
397 static int ext4_destroy_inline_data_nolock(handle_t
*handle
,
400 struct ext4_inode_info
*ei
= EXT4_I(inode
);
401 struct ext4_xattr_ibody_find is
= {
402 .s
= { .not_found
= 0, },
404 struct ext4_xattr_info i
= {
405 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
406 .name
= EXT4_XATTR_SYSTEM_DATA
,
412 if (!ei
->i_inline_off
)
415 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
419 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
423 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
424 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
428 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
432 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
433 0, EXT4_MIN_INLINE_DATA_SIZE
);
435 if (EXT4_HAS_INCOMPAT_FEATURE(inode
->i_sb
,
436 EXT4_FEATURE_INCOMPAT_EXTENTS
)) {
437 if (S_ISDIR(inode
->i_mode
) ||
438 S_ISREG(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) {
439 ext4_set_inode_flag(inode
, EXT4_INODE_EXTENTS
);
440 ext4_ext_tree_init(handle
, inode
);
443 ext4_clear_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
446 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
448 EXT4_I(inode
)->i_inline_off
= 0;
449 EXT4_I(inode
)->i_inline_size
= 0;
450 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
453 if (error
== -ENODATA
)
458 static int ext4_read_inline_page(struct inode
*inode
, struct page
*page
)
463 struct ext4_iloc iloc
;
465 BUG_ON(!PageLocked(page
));
466 BUG_ON(!ext4_has_inline_data(inode
));
469 if (!EXT4_I(inode
)->i_inline_off
) {
470 ext4_warning(inode
->i_sb
, "inode %lu doesn't have inline data.",
475 ret
= ext4_get_inode_loc(inode
, &iloc
);
479 len
= min_t(size_t, ext4_get_inline_size(inode
), i_size_read(inode
));
480 kaddr
= kmap_atomic(page
);
481 ret
= ext4_read_inline_data(inode
, kaddr
, len
, &iloc
);
482 flush_dcache_page(page
);
483 kunmap_atomic(kaddr
);
484 zero_user_segment(page
, len
, PAGE_CACHE_SIZE
);
485 SetPageUptodate(page
);
492 int ext4_readpage_inline(struct inode
*inode
, struct page
*page
)
496 down_read(&EXT4_I(inode
)->xattr_sem
);
497 if (!ext4_has_inline_data(inode
)) {
498 up_read(&EXT4_I(inode
)->xattr_sem
);
503 * Current inline data can only exist in the 1st page,
504 * So for all the other pages, just set them uptodate.
507 ret
= ext4_read_inline_page(inode
, page
);
508 else if (!PageUptodate(page
)) {
509 zero_user_segment(page
, 0, PAGE_CACHE_SIZE
);
510 SetPageUptodate(page
);
513 up_read(&EXT4_I(inode
)->xattr_sem
);
516 return ret
>= 0 ? 0 : ret
;
519 static int ext4_convert_inline_data_to_extent(struct address_space
*mapping
,
523 int ret
, needed_blocks
;
524 handle_t
*handle
= NULL
;
525 int retries
= 0, sem_held
= 0;
526 struct page
*page
= NULL
;
528 struct ext4_iloc iloc
;
530 if (!ext4_has_inline_data(inode
)) {
532 * clear the flag so that no new write
533 * will trap here again.
535 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
539 needed_blocks
= ext4_writepage_trans_blocks(inode
);
541 ret
= ext4_get_inode_loc(inode
, &iloc
);
546 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
547 if (IS_ERR(handle
)) {
548 ret
= PTR_ERR(handle
);
553 /* We cannot recurse into the filesystem as the transaction is already
555 flags
|= AOP_FLAG_NOFS
;
557 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
563 down_write(&EXT4_I(inode
)->xattr_sem
);
565 /* If some one has already done this for us, just exit. */
566 if (!ext4_has_inline_data(inode
)) {
572 to
= ext4_get_inline_size(inode
);
573 if (!PageUptodate(page
)) {
574 ret
= ext4_read_inline_page(inode
, page
);
579 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
583 if (ext4_should_dioread_nolock(inode
))
584 ret
= __block_write_begin(page
, from
, to
, ext4_get_block_write
);
586 ret
= __block_write_begin(page
, from
, to
, ext4_get_block
);
588 if (!ret
&& ext4_should_journal_data(inode
)) {
589 ret
= ext4_walk_page_buffers(handle
, page_buffers(page
),
591 do_journal_get_write_access
);
596 page_cache_release(page
);
597 ext4_orphan_add(handle
, inode
);
598 up_write(&EXT4_I(inode
)->xattr_sem
);
600 ext4_journal_stop(handle
);
602 ext4_truncate_failed_write(inode
);
604 * If truncate failed early the inode might
605 * still be on the orphan list; we need to
606 * make sure the inode is removed from the
607 * orphan list in that case.
610 ext4_orphan_del(NULL
, inode
);
613 if (ret
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
616 block_commit_write(page
, from
, to
);
620 page_cache_release(page
);
623 up_write(&EXT4_I(inode
)->xattr_sem
);
625 ext4_journal_stop(handle
);
631 * Try to write data in the inode.
632 * If the inode has inline data, check whether the new write can be
633 * in the inode also. If not, create the page the handle, move the data
634 * to the page make it update and let the later codes create extent for it.
636 int ext4_try_to_write_inline_data(struct address_space
*mapping
,
638 loff_t pos
, unsigned len
,
645 struct ext4_iloc iloc
;
647 if (pos
+ len
> ext4_get_max_inline_size(inode
))
650 ret
= ext4_get_inode_loc(inode
, &iloc
);
655 * The possible write could happen in the inode,
656 * so try to reserve the space in inode first.
658 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
659 if (IS_ERR(handle
)) {
660 ret
= PTR_ERR(handle
);
665 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
666 if (ret
&& ret
!= -ENOSPC
)
669 /* We don't have space in inline inode, so convert it to extent. */
670 if (ret
== -ENOSPC
) {
671 ext4_journal_stop(handle
);
676 flags
|= AOP_FLAG_NOFS
;
678 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
685 down_read(&EXT4_I(inode
)->xattr_sem
);
686 if (!ext4_has_inline_data(inode
)) {
689 page_cache_release(page
);
693 if (!PageUptodate(page
)) {
694 ret
= ext4_read_inline_page(inode
, page
);
702 up_read(&EXT4_I(inode
)->xattr_sem
);
705 ext4_journal_stop(handle
);
709 return ext4_convert_inline_data_to_extent(mapping
,
713 int ext4_write_inline_data_end(struct inode
*inode
, loff_t pos
, unsigned len
,
714 unsigned copied
, struct page
*page
)
718 struct ext4_iloc iloc
;
720 if (unlikely(copied
< len
)) {
721 if (!PageUptodate(page
)) {
727 ret
= ext4_get_inode_loc(inode
, &iloc
);
729 ext4_std_error(inode
->i_sb
, ret
);
734 down_write(&EXT4_I(inode
)->xattr_sem
);
735 BUG_ON(!ext4_has_inline_data(inode
));
737 kaddr
= kmap_atomic(page
);
738 ext4_write_inline_data(inode
, &iloc
, kaddr
, pos
, len
);
739 kunmap_atomic(kaddr
);
740 SetPageUptodate(page
);
741 /* clear page dirty so that writepages wouldn't work for us. */
742 ClearPageDirty(page
);
744 up_write(&EXT4_I(inode
)->xattr_sem
);
751 ext4_journalled_write_inline_data(struct inode
*inode
,
757 struct ext4_iloc iloc
;
759 ret
= ext4_get_inode_loc(inode
, &iloc
);
761 ext4_std_error(inode
->i_sb
, ret
);
765 down_write(&EXT4_I(inode
)->xattr_sem
);
766 kaddr
= kmap_atomic(page
);
767 ext4_write_inline_data(inode
, &iloc
, kaddr
, 0, len
);
768 kunmap_atomic(kaddr
);
769 up_write(&EXT4_I(inode
)->xattr_sem
);
775 * Try to make the page cache and handle ready for the inline data case.
776 * We can call this function in 2 cases:
777 * 1. The inode is created and the first write exceeds inline size. We can
778 * clear the inode state safely.
779 * 2. The inode has inline data, then we need to read the data, make it
780 * update and dirty so that ext4_da_writepages can handle it. We don't
781 * need to start the journal since the file's metatdata isn't changed now.
783 static int ext4_da_convert_inline_data_to_extent(struct address_space
*mapping
,
788 int ret
= 0, inline_size
;
791 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
795 down_read(&EXT4_I(inode
)->xattr_sem
);
796 if (!ext4_has_inline_data(inode
)) {
797 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
801 inline_size
= ext4_get_inline_size(inode
);
803 if (!PageUptodate(page
)) {
804 ret
= ext4_read_inline_page(inode
, page
);
809 ret
= __block_write_begin(page
, 0, inline_size
,
810 ext4_da_get_block_prep
);
812 ext4_truncate_failed_write(inode
);
817 SetPageUptodate(page
);
818 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
819 *fsdata
= (void *)CONVERT_INLINE_DATA
;
822 up_read(&EXT4_I(inode
)->xattr_sem
);
825 page_cache_release(page
);
831 * Prepare the write for the inline data.
832 * If the the data can be written into the inode, we just read
833 * the page and make it uptodate, and start the journal.
834 * Otherwise read the page, makes it dirty so that it can be
835 * handle in writepages(the i_disksize update is left to the
836 * normal ext4_da_write_end).
838 int ext4_da_write_inline_data_begin(struct address_space
*mapping
,
840 loff_t pos
, unsigned len
,
845 int ret
, inline_size
;
848 struct ext4_iloc iloc
;
851 ret
= ext4_get_inode_loc(inode
, &iloc
);
856 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
857 if (IS_ERR(handle
)) {
858 ret
= PTR_ERR(handle
);
862 inline_size
= ext4_get_max_inline_size(inode
);
865 if (inline_size
>= pos
+ len
) {
866 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
867 if (ret
&& ret
!= -ENOSPC
)
871 if (ret
== -ENOSPC
) {
872 ret
= ext4_da_convert_inline_data_to_extent(mapping
,
876 ext4_journal_stop(handle
);
877 if (ret
== -ENOSPC
&&
878 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
884 * We cannot recurse into the filesystem as the transaction
885 * is already started.
887 flags
|= AOP_FLAG_NOFS
;
889 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
895 down_read(&EXT4_I(inode
)->xattr_sem
);
896 if (!ext4_has_inline_data(inode
)) {
898 goto out_release_page
;
901 if (!PageUptodate(page
)) {
902 ret
= ext4_read_inline_page(inode
, page
);
904 goto out_release_page
;
907 up_read(&EXT4_I(inode
)->xattr_sem
);
912 up_read(&EXT4_I(inode
)->xattr_sem
);
914 page_cache_release(page
);
916 ext4_journal_stop(handle
);
922 int ext4_da_write_inline_data_end(struct inode
*inode
, loff_t pos
,
923 unsigned len
, unsigned copied
,
926 int i_size_changed
= 0;
928 copied
= ext4_write_inline_data_end(inode
, pos
, len
, copied
, page
);
931 * No need to use i_size_read() here, the i_size
932 * cannot change under us because we hold i_mutex.
934 * But it's important to update i_size while still holding page lock:
935 * page writeout could otherwise come in and zero beyond i_size.
937 if (pos
+copied
> inode
->i_size
) {
938 i_size_write(inode
, pos
+copied
);
942 page_cache_release(page
);
945 * Don't mark the inode dirty under page lock. First, it unnecessarily
946 * makes the holding time of page lock longer. Second, it forces lock
947 * ordering of page lock and transaction start for journaling
951 mark_inode_dirty(inode
);
956 #ifdef INLINE_DIR_DEBUG
957 void ext4_show_inline_dir(struct inode
*dir
, struct buffer_head
*bh
,
958 void *inline_start
, int inline_size
)
961 unsigned short de_len
;
962 struct ext4_dir_entry_2
*de
= inline_start
;
963 void *dlimit
= inline_start
+ inline_size
;
965 trace_printk("inode %lu\n", dir
->i_ino
);
967 while ((void *)de
< dlimit
) {
968 de_len
= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
969 trace_printk("de: off %u rlen %u name %*.s nlen %u ino %u\n",
970 offset
, de_len
, de
->name_len
, de
->name
,
971 de
->name_len
, le32_to_cpu(de
->inode
));
972 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
973 inline_start
, inline_size
, offset
))
977 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
981 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
985 * Add a new entry into a inline dir.
986 * It will return -ENOSPC if no space is available, and -EIO
987 * and -EEXIST if directory entry already exists.
989 static int ext4_add_dirent_to_inline(handle_t
*handle
,
990 struct dentry
*dentry
,
992 struct ext4_iloc
*iloc
,
993 void *inline_start
, int inline_size
)
995 struct inode
*dir
= dentry
->d_parent
->d_inode
;
996 const char *name
= dentry
->d_name
.name
;
997 int namelen
= dentry
->d_name
.len
;
999 struct ext4_dir_entry_2
*de
;
1001 err
= ext4_find_dest_de(dir
, inode
, iloc
->bh
,
1002 inline_start
, inline_size
,
1003 name
, namelen
, &de
);
1007 BUFFER_TRACE(iloc
->bh
, "get_write_access");
1008 err
= ext4_journal_get_write_access(handle
, iloc
->bh
);
1011 ext4_insert_dentry(inode
, de
, inline_size
, name
, namelen
);
1013 ext4_show_inline_dir(dir
, iloc
->bh
, inline_start
, inline_size
);
1016 * XXX shouldn't update any times until successful
1017 * completion of syscall, but too many callers depend
1020 * XXX similarly, too many callers depend on
1021 * ext4_new_inode() setting the times, but error
1022 * recovery deletes the inode, so the worst that can
1023 * happen is that the times are slightly out of date
1024 * and/or different from the directory change time.
1026 dir
->i_mtime
= dir
->i_ctime
= ext4_current_time(dir
);
1027 ext4_update_dx_flag(dir
);
1029 ext4_mark_inode_dirty(handle
, dir
);
1033 static void *ext4_get_inline_xattr_pos(struct inode
*inode
,
1034 struct ext4_iloc
*iloc
)
1036 struct ext4_xattr_entry
*entry
;
1037 struct ext4_xattr_ibody_header
*header
;
1039 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
1041 header
= IHDR(inode
, ext4_raw_inode(iloc
));
1042 entry
= (struct ext4_xattr_entry
*)((void *)ext4_raw_inode(iloc
) +
1043 EXT4_I(inode
)->i_inline_off
);
1045 return (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
);
1048 /* Set the final de to cover the whole block. */
1049 static void ext4_update_final_de(void *de_buf
, int old_size
, int new_size
)
1051 struct ext4_dir_entry_2
*de
, *prev_de
;
1055 de
= (struct ext4_dir_entry_2
*)de_buf
;
1057 limit
= de_buf
+ old_size
;
1060 de_len
= ext4_rec_len_from_disk(de
->rec_len
, old_size
);
1062 de
= (struct ext4_dir_entry_2
*)de_buf
;
1063 } while (de_buf
< limit
);
1065 prev_de
->rec_len
= ext4_rec_len_to_disk(de_len
+ new_size
-
1066 old_size
, new_size
);
1068 /* this is just created, so create an empty entry. */
1070 de
->rec_len
= ext4_rec_len_to_disk(new_size
, new_size
);
1074 static int ext4_update_inline_dir(handle_t
*handle
, struct inode
*dir
,
1075 struct ext4_iloc
*iloc
)
1078 int old_size
= EXT4_I(dir
)->i_inline_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1079 int new_size
= get_max_inline_xattr_value_size(dir
, iloc
);
1081 if (new_size
- old_size
<= EXT4_DIR_REC_LEN(1))
1084 ret
= ext4_update_inline_data(handle
, dir
,
1085 new_size
+ EXT4_MIN_INLINE_DATA_SIZE
);
1089 ext4_update_final_de(ext4_get_inline_xattr_pos(dir
, iloc
), old_size
,
1090 EXT4_I(dir
)->i_inline_size
-
1091 EXT4_MIN_INLINE_DATA_SIZE
);
1092 dir
->i_size
= EXT4_I(dir
)->i_disksize
= EXT4_I(dir
)->i_inline_size
;
1096 static void ext4_restore_inline_data(handle_t
*handle
, struct inode
*inode
,
1097 struct ext4_iloc
*iloc
,
1098 void *buf
, int inline_size
)
1100 ext4_create_inline_data(handle
, inode
, inline_size
);
1101 ext4_write_inline_data(inode
, iloc
, buf
, 0, inline_size
);
1102 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1105 static int ext4_finish_convert_inline_dir(handle_t
*handle
,
1106 struct inode
*inode
,
1107 struct buffer_head
*dir_block
,
1111 int err
, csum_size
= 0, header_size
= 0;
1112 struct ext4_dir_entry_2
*de
;
1113 struct ext4_dir_entry_tail
*t
;
1114 void *target
= dir_block
->b_data
;
1117 * First create "." and ".." and then copy the dir information
1118 * back to the block.
1120 de
= (struct ext4_dir_entry_2
*)target
;
1121 de
= ext4_init_dot_dotdot(inode
, de
,
1122 inode
->i_sb
->s_blocksize
, csum_size
,
1123 le32_to_cpu(((struct ext4_dir_entry_2
*)buf
)->inode
), 1);
1124 header_size
= (void *)de
- target
;
1126 memcpy((void *)de
, buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1127 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1129 if (EXT4_HAS_RO_COMPAT_FEATURE(inode
->i_sb
,
1130 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM
))
1131 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1133 inode
->i_size
= inode
->i_sb
->s_blocksize
;
1134 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
1135 EXT4_I(inode
)->i_disksize
= inode
->i_sb
->s_blocksize
;
1136 ext4_update_final_de(dir_block
->b_data
,
1137 inline_size
- EXT4_INLINE_DOTDOT_SIZE
+ header_size
,
1138 inode
->i_sb
->s_blocksize
- csum_size
);
1141 t
= EXT4_DIRENT_TAIL(dir_block
->b_data
,
1142 inode
->i_sb
->s_blocksize
);
1143 initialize_dirent_tail(t
, inode
->i_sb
->s_blocksize
);
1145 set_buffer_uptodate(dir_block
);
1146 err
= ext4_handle_dirty_dirent_node(handle
, inode
, dir_block
);
1149 set_buffer_verified(dir_block
);
1154 static int ext4_convert_inline_data_nolock(handle_t
*handle
,
1155 struct inode
*inode
,
1156 struct ext4_iloc
*iloc
)
1160 struct buffer_head
*data_bh
= NULL
;
1161 struct ext4_map_blocks map
;
1164 inline_size
= ext4_get_inline_size(inode
);
1165 buf
= kmalloc(inline_size
, GFP_NOFS
);
1171 error
= ext4_read_inline_data(inode
, buf
, inline_size
, iloc
);
1176 * Make sure the inline directory entries pass checks before we try to
1177 * convert them, so that we avoid touching stuff that needs fsck.
1179 if (S_ISDIR(inode
->i_mode
)) {
1180 error
= ext4_check_all_de(inode
, iloc
->bh
,
1181 buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1182 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1187 error
= ext4_destroy_inline_data_nolock(handle
, inode
);
1194 error
= ext4_map_blocks(handle
, inode
, &map
, EXT4_GET_BLOCKS_CREATE
);
1197 if (!(map
.m_flags
& EXT4_MAP_MAPPED
)) {
1202 data_bh
= sb_getblk(inode
->i_sb
, map
.m_pblk
);
1208 lock_buffer(data_bh
);
1209 error
= ext4_journal_get_create_access(handle
, data_bh
);
1211 unlock_buffer(data_bh
);
1215 memset(data_bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1217 if (!S_ISDIR(inode
->i_mode
)) {
1218 memcpy(data_bh
->b_data
, buf
, inline_size
);
1219 set_buffer_uptodate(data_bh
);
1220 error
= ext4_handle_dirty_metadata(handle
,
1223 error
= ext4_finish_convert_inline_dir(handle
, inode
, data_bh
,
1227 unlock_buffer(data_bh
);
1230 ext4_restore_inline_data(handle
, inode
, iloc
, buf
, inline_size
);
1239 * Try to add the new entry to the inline data.
1240 * If succeeds, return 0. If not, extended the inline dir and copied data to
1241 * the new created block.
1243 int ext4_try_add_inline_entry(handle_t
*handle
, struct dentry
*dentry
,
1244 struct inode
*inode
)
1246 int ret
, inline_size
;
1248 struct ext4_iloc iloc
;
1249 struct inode
*dir
= dentry
->d_parent
->d_inode
;
1251 ret
= ext4_get_inode_loc(dir
, &iloc
);
1255 down_write(&EXT4_I(dir
)->xattr_sem
);
1256 if (!ext4_has_inline_data(dir
))
1259 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1260 EXT4_INLINE_DOTDOT_SIZE
;
1261 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1263 ret
= ext4_add_dirent_to_inline(handle
, dentry
, inode
, &iloc
,
1264 inline_start
, inline_size
);
1268 /* check whether it can be inserted to inline xattr space. */
1269 inline_size
= EXT4_I(dir
)->i_inline_size
-
1270 EXT4_MIN_INLINE_DATA_SIZE
;
1272 /* Try to use the xattr space.*/
1273 ret
= ext4_update_inline_dir(handle
, dir
, &iloc
);
1274 if (ret
&& ret
!= -ENOSPC
)
1277 inline_size
= EXT4_I(dir
)->i_inline_size
-
1278 EXT4_MIN_INLINE_DATA_SIZE
;
1282 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1284 ret
= ext4_add_dirent_to_inline(handle
, dentry
, inode
, &iloc
,
1285 inline_start
, inline_size
);
1292 * The inline space is filled up, so create a new block for it.
1293 * As the extent tree will be created, we have to save the inline
1296 ret
= ext4_convert_inline_data_nolock(handle
, dir
, &iloc
);
1299 ext4_mark_inode_dirty(handle
, dir
);
1300 up_write(&EXT4_I(dir
)->xattr_sem
);
1306 * This function fills a red-black tree with information from an
1307 * inlined dir. It returns the number directory entries loaded
1308 * into the tree. If there is an error it is returned in err.
1310 int htree_inlinedir_to_tree(struct file
*dir_file
,
1311 struct inode
*dir
, ext4_lblk_t block
,
1312 struct dx_hash_info
*hinfo
,
1313 __u32 start_hash
, __u32 start_minor_hash
,
1314 int *has_inline_data
)
1316 int err
= 0, count
= 0;
1317 unsigned int parent_ino
;
1319 struct ext4_dir_entry_2
*de
;
1320 struct inode
*inode
= file_inode(dir_file
);
1321 int ret
, inline_size
= 0;
1322 struct ext4_iloc iloc
;
1323 void *dir_buf
= NULL
;
1324 struct ext4_dir_entry_2 fake
;
1326 ret
= ext4_get_inode_loc(inode
, &iloc
);
1330 down_read(&EXT4_I(inode
)->xattr_sem
);
1331 if (!ext4_has_inline_data(inode
)) {
1332 up_read(&EXT4_I(inode
)->xattr_sem
);
1333 *has_inline_data
= 0;
1337 inline_size
= ext4_get_inline_size(inode
);
1338 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1341 up_read(&EXT4_I(inode
)->xattr_sem
);
1345 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1346 up_read(&EXT4_I(inode
)->xattr_sem
);
1351 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1352 while (pos
< inline_size
) {
1354 * As inlined dir doesn't store any information about '.' and
1355 * only the inode number of '..' is stored, we have to handle
1359 fake
.inode
= cpu_to_le32(inode
->i_ino
);
1361 strcpy(fake
.name
, ".");
1362 fake
.rec_len
= ext4_rec_len_to_disk(
1363 EXT4_DIR_REC_LEN(fake
.name_len
),
1365 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1367 pos
= EXT4_INLINE_DOTDOT_OFFSET
;
1368 } else if (pos
== EXT4_INLINE_DOTDOT_OFFSET
) {
1369 fake
.inode
= cpu_to_le32(parent_ino
);
1371 strcpy(fake
.name
, "..");
1372 fake
.rec_len
= ext4_rec_len_to_disk(
1373 EXT4_DIR_REC_LEN(fake
.name_len
),
1375 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1377 pos
= EXT4_INLINE_DOTDOT_SIZE
;
1379 de
= (struct ext4_dir_entry_2
*)(dir_buf
+ pos
);
1380 pos
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1381 if (ext4_check_dir_entry(inode
, dir_file
, de
,
1383 inline_size
, pos
)) {
1389 ext4fs_dirhash(de
->name
, de
->name_len
, hinfo
);
1390 if ((hinfo
->hash
< start_hash
) ||
1391 ((hinfo
->hash
== start_hash
) &&
1392 (hinfo
->minor_hash
< start_minor_hash
)))
1396 err
= ext4_htree_store_dirent(dir_file
,
1397 hinfo
->hash
, hinfo
->minor_hash
, de
);
1412 * So this function is called when the volume is mkfsed with
1413 * dir_index disabled. In order to keep f_pos persistent
1414 * after we convert from an inlined dir to a blocked based,
1415 * we just pretend that we are a normal dir and return the
1416 * offset as if '.' and '..' really take place.
1419 int ext4_read_inline_dir(struct file
*file
,
1420 struct dir_context
*ctx
,
1421 int *has_inline_data
)
1423 unsigned int offset
, parent_ino
;
1425 struct ext4_dir_entry_2
*de
;
1426 struct super_block
*sb
;
1427 struct inode
*inode
= file_inode(file
);
1428 int ret
, inline_size
= 0;
1429 struct ext4_iloc iloc
;
1430 void *dir_buf
= NULL
;
1431 int dotdot_offset
, dotdot_size
, extra_offset
, extra_size
;
1433 ret
= ext4_get_inode_loc(inode
, &iloc
);
1437 down_read(&EXT4_I(inode
)->xattr_sem
);
1438 if (!ext4_has_inline_data(inode
)) {
1439 up_read(&EXT4_I(inode
)->xattr_sem
);
1440 *has_inline_data
= 0;
1444 inline_size
= ext4_get_inline_size(inode
);
1445 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1448 up_read(&EXT4_I(inode
)->xattr_sem
);
1452 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1453 up_read(&EXT4_I(inode
)->xattr_sem
);
1459 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1463 * dotdot_offset and dotdot_size is the real offset and
1464 * size for ".." and "." if the dir is block based while
1465 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1466 * So we will use extra_offset and extra_size to indicate them
1467 * during the inline dir iteration.
1469 dotdot_offset
= EXT4_DIR_REC_LEN(1);
1470 dotdot_size
= dotdot_offset
+ EXT4_DIR_REC_LEN(2);
1471 extra_offset
= dotdot_size
- EXT4_INLINE_DOTDOT_SIZE
;
1472 extra_size
= extra_offset
+ inline_size
;
1475 * If the version has changed since the last call to
1476 * readdir(2), then we might be pointing to an invalid
1477 * dirent right now. Scan from the start of the inline
1480 if (file
->f_version
!= inode
->i_version
) {
1481 for (i
= 0; i
< extra_size
&& i
< offset
;) {
1483 * "." is with offset 0 and
1484 * ".." is dotdot_offset.
1489 } else if (i
== dotdot_offset
) {
1493 /* for other entry, the real offset in
1494 * the buf has to be tuned accordingly.
1496 de
= (struct ext4_dir_entry_2
*)
1497 (dir_buf
+ i
- extra_offset
);
1498 /* It's too expensive to do a full
1499 * dirent test each time round this
1500 * loop, but we do have to test at
1501 * least that it is non-zero. A
1502 * failure will be detected in the
1503 * dirent test below. */
1504 if (ext4_rec_len_from_disk(de
->rec_len
, extra_size
)
1505 < EXT4_DIR_REC_LEN(1))
1507 i
+= ext4_rec_len_from_disk(de
->rec_len
,
1512 file
->f_version
= inode
->i_version
;
1515 while (ctx
->pos
< extra_size
) {
1516 if (ctx
->pos
== 0) {
1517 if (!dir_emit(ctx
, ".", 1, inode
->i_ino
, DT_DIR
))
1519 ctx
->pos
= dotdot_offset
;
1523 if (ctx
->pos
== dotdot_offset
) {
1524 if (!dir_emit(ctx
, "..", 2, parent_ino
, DT_DIR
))
1526 ctx
->pos
= dotdot_size
;
1530 de
= (struct ext4_dir_entry_2
*)
1531 (dir_buf
+ ctx
->pos
- extra_offset
);
1532 if (ext4_check_dir_entry(inode
, file
, de
, iloc
.bh
, dir_buf
,
1533 extra_size
, ctx
->pos
))
1535 if (le32_to_cpu(de
->inode
)) {
1536 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1537 le32_to_cpu(de
->inode
),
1538 get_dtype(sb
, de
->file_type
)))
1541 ctx
->pos
+= ext4_rec_len_from_disk(de
->rec_len
, extra_size
);
1549 struct buffer_head
*ext4_get_first_inline_block(struct inode
*inode
,
1550 struct ext4_dir_entry_2
**parent_de
,
1553 struct ext4_iloc iloc
;
1555 *retval
= ext4_get_inode_loc(inode
, &iloc
);
1559 *parent_de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1565 * Try to create the inline data for the new dir.
1566 * If it succeeds, return 0, otherwise return the error.
1567 * In case of ENOSPC, the caller should create the normal disk layout dir.
1569 int ext4_try_create_inline_dir(handle_t
*handle
, struct inode
*parent
,
1570 struct inode
*inode
)
1572 int ret
, inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1573 struct ext4_iloc iloc
;
1574 struct ext4_dir_entry_2
*de
;
1576 ret
= ext4_get_inode_loc(inode
, &iloc
);
1580 ret
= ext4_prepare_inline_data(handle
, inode
, inline_size
);
1585 * For inline dir, we only save the inode information for the ".."
1586 * and create a fake dentry to cover the left space.
1588 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1589 de
->inode
= cpu_to_le32(parent
->i_ino
);
1590 de
= (struct ext4_dir_entry_2
*)((void *)de
+ EXT4_INLINE_DOTDOT_SIZE
);
1592 de
->rec_len
= ext4_rec_len_to_disk(
1593 inline_size
- EXT4_INLINE_DOTDOT_SIZE
,
1595 set_nlink(inode
, 2);
1596 inode
->i_size
= EXT4_I(inode
)->i_disksize
= inline_size
;
1602 struct buffer_head
*ext4_find_inline_entry(struct inode
*dir
,
1603 const struct qstr
*d_name
,
1604 struct ext4_dir_entry_2
**res_dir
,
1605 int *has_inline_data
)
1608 struct ext4_iloc iloc
;
1612 if (ext4_get_inode_loc(dir
, &iloc
))
1615 down_read(&EXT4_I(dir
)->xattr_sem
);
1616 if (!ext4_has_inline_data(dir
)) {
1617 *has_inline_data
= 0;
1621 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1622 EXT4_INLINE_DOTDOT_SIZE
;
1623 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1624 ret
= search_dir(iloc
.bh
, inline_start
, inline_size
,
1625 dir
, d_name
, 0, res_dir
);
1631 if (ext4_get_inline_size(dir
) == EXT4_MIN_INLINE_DATA_SIZE
)
1634 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1635 inline_size
= ext4_get_inline_size(dir
) - EXT4_MIN_INLINE_DATA_SIZE
;
1637 ret
= search_dir(iloc
.bh
, inline_start
, inline_size
,
1638 dir
, d_name
, 0, res_dir
);
1646 up_read(&EXT4_I(dir
)->xattr_sem
);
1650 int ext4_delete_inline_entry(handle_t
*handle
,
1652 struct ext4_dir_entry_2
*de_del
,
1653 struct buffer_head
*bh
,
1654 int *has_inline_data
)
1656 int err
, inline_size
;
1657 struct ext4_iloc iloc
;
1660 err
= ext4_get_inode_loc(dir
, &iloc
);
1664 down_write(&EXT4_I(dir
)->xattr_sem
);
1665 if (!ext4_has_inline_data(dir
)) {
1666 *has_inline_data
= 0;
1670 if ((void *)de_del
- ((void *)ext4_raw_inode(&iloc
)->i_block
) <
1671 EXT4_MIN_INLINE_DATA_SIZE
) {
1672 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1673 EXT4_INLINE_DOTDOT_SIZE
;
1674 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
-
1675 EXT4_INLINE_DOTDOT_SIZE
;
1677 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1678 inline_size
= ext4_get_inline_size(dir
) -
1679 EXT4_MIN_INLINE_DATA_SIZE
;
1682 BUFFER_TRACE(bh
, "get_write_access");
1683 err
= ext4_journal_get_write_access(handle
, bh
);
1687 err
= ext4_generic_delete_entry(handle
, dir
, de_del
, bh
,
1688 inline_start
, inline_size
, 0);
1692 BUFFER_TRACE(bh
, "call ext4_handle_dirty_metadata");
1693 err
= ext4_mark_inode_dirty(handle
, dir
);
1697 ext4_show_inline_dir(dir
, iloc
.bh
, inline_start
, inline_size
);
1699 up_write(&EXT4_I(dir
)->xattr_sem
);
1702 ext4_std_error(dir
->i_sb
, err
);
1707 * Get the inline dentry at offset.
1709 static inline struct ext4_dir_entry_2
*
1710 ext4_get_inline_entry(struct inode
*inode
,
1711 struct ext4_iloc
*iloc
,
1712 unsigned int offset
,
1713 void **inline_start
,
1718 BUG_ON(offset
> ext4_get_inline_size(inode
));
1720 if (offset
< EXT4_MIN_INLINE_DATA_SIZE
) {
1721 inline_pos
= (void *)ext4_raw_inode(iloc
)->i_block
;
1722 *inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1724 inline_pos
= ext4_get_inline_xattr_pos(inode
, iloc
);
1725 offset
-= EXT4_MIN_INLINE_DATA_SIZE
;
1726 *inline_size
= ext4_get_inline_size(inode
) -
1727 EXT4_MIN_INLINE_DATA_SIZE
;
1731 *inline_start
= inline_pos
;
1732 return (struct ext4_dir_entry_2
*)(inline_pos
+ offset
);
1735 int empty_inline_dir(struct inode
*dir
, int *has_inline_data
)
1737 int err
, inline_size
;
1738 struct ext4_iloc iloc
;
1740 unsigned int offset
;
1741 struct ext4_dir_entry_2
*de
;
1744 err
= ext4_get_inode_loc(dir
, &iloc
);
1746 EXT4_ERROR_INODE(dir
, "error %d getting inode %lu block",
1751 down_read(&EXT4_I(dir
)->xattr_sem
);
1752 if (!ext4_has_inline_data(dir
)) {
1753 *has_inline_data
= 0;
1757 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1758 if (!le32_to_cpu(de
->inode
)) {
1759 ext4_warning(dir
->i_sb
,
1760 "bad inline directory (dir #%lu) - no `..'",
1766 offset
= EXT4_INLINE_DOTDOT_SIZE
;
1767 while (offset
< dir
->i_size
) {
1768 de
= ext4_get_inline_entry(dir
, &iloc
, offset
,
1769 &inline_pos
, &inline_size
);
1770 if (ext4_check_dir_entry(dir
, NULL
, de
,
1771 iloc
.bh
, inline_pos
,
1772 inline_size
, offset
)) {
1773 ext4_warning(dir
->i_sb
,
1774 "bad inline directory (dir #%lu) - "
1775 "inode %u, rec_len %u, name_len %d"
1777 dir
->i_ino
, le32_to_cpu(de
->inode
),
1778 le16_to_cpu(de
->rec_len
), de
->name_len
,
1783 if (le32_to_cpu(de
->inode
)) {
1787 offset
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1791 up_read(&EXT4_I(dir
)->xattr_sem
);
1796 int ext4_destroy_inline_data(handle_t
*handle
, struct inode
*inode
)
1800 down_write(&EXT4_I(inode
)->xattr_sem
);
1801 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
1802 up_write(&EXT4_I(inode
)->xattr_sem
);
1807 int ext4_inline_data_fiemap(struct inode
*inode
,
1808 struct fiemap_extent_info
*fieinfo
,
1813 __u32 flags
= FIEMAP_EXTENT_DATA_INLINE
| FIEMAP_EXTENT_LAST
;
1815 struct ext4_iloc iloc
;
1817 down_read(&EXT4_I(inode
)->xattr_sem
);
1818 if (!ext4_has_inline_data(inode
)) {
1823 error
= ext4_get_inode_loc(inode
, &iloc
);
1827 physical
= (__u64
)iloc
.bh
->b_blocknr
<< inode
->i_sb
->s_blocksize_bits
;
1828 physical
+= (char *)ext4_raw_inode(&iloc
) - iloc
.bh
->b_data
;
1829 physical
+= offsetof(struct ext4_inode
, i_block
);
1830 length
= i_size_read(inode
);
1833 error
= fiemap_fill_next_extent(fieinfo
, 0, physical
,
1837 up_read(&EXT4_I(inode
)->xattr_sem
);
1838 return (error
< 0 ? error
: 0);
1842 * Called during xattr set, and if we can sparse space 'needed',
1843 * just create the extent tree evict the data to the outer block.
1845 * We use jbd2 instead of page cache to move data to the 1st block
1846 * so that the whole transaction can be committed as a whole and
1847 * the data isn't lost because of the delayed page cache write.
1849 int ext4_try_to_evict_inline_data(handle_t
*handle
,
1850 struct inode
*inode
,
1854 struct ext4_xattr_entry
*entry
;
1855 struct ext4_inode
*raw_inode
;
1856 struct ext4_iloc iloc
;
1858 error
= ext4_get_inode_loc(inode
, &iloc
);
1862 raw_inode
= ext4_raw_inode(&iloc
);
1863 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
1864 EXT4_I(inode
)->i_inline_off
);
1865 if (EXT4_XATTR_LEN(entry
->e_name_len
) +
1866 EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
)) < needed
) {
1871 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
1877 void ext4_inline_data_truncate(struct inode
*inode
, int *has_inline
)
1880 int inline_size
, value_len
, needed_blocks
;
1883 struct ext4_xattr_ibody_find is
= {
1884 .s
= { .not_found
= -ENODATA
, },
1886 struct ext4_xattr_info i
= {
1887 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
1888 .name
= EXT4_XATTR_SYSTEM_DATA
,
1892 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1893 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, needed_blocks
);
1897 down_write(&EXT4_I(inode
)->xattr_sem
);
1898 if (!ext4_has_inline_data(inode
)) {
1900 ext4_journal_stop(handle
);
1904 if (ext4_orphan_add(handle
, inode
))
1907 if (ext4_get_inode_loc(inode
, &is
.iloc
))
1910 down_write(&EXT4_I(inode
)->i_data_sem
);
1911 i_size
= inode
->i_size
;
1912 inline_size
= ext4_get_inline_size(inode
);
1913 EXT4_I(inode
)->i_disksize
= i_size
;
1915 if (i_size
< inline_size
) {
1916 /* Clear the content in the xattr space. */
1917 if (inline_size
> EXT4_MIN_INLINE_DATA_SIZE
) {
1918 if (ext4_xattr_ibody_find(inode
, &i
, &is
))
1921 BUG_ON(is
.s
.not_found
);
1923 value_len
= le32_to_cpu(is
.s
.here
->e_value_size
);
1924 value
= kmalloc(value_len
, GFP_NOFS
);
1928 if (ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
1933 i
.value_len
= i_size
> EXT4_MIN_INLINE_DATA_SIZE
?
1934 i_size
- EXT4_MIN_INLINE_DATA_SIZE
: 0;
1935 if (ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
))
1939 /* Clear the content within i_blocks. */
1940 if (i_size
< EXT4_MIN_INLINE_DATA_SIZE
) {
1941 void *p
= (void *) ext4_raw_inode(&is
.iloc
)->i_block
;
1942 memset(p
+ i_size
, 0,
1943 EXT4_MIN_INLINE_DATA_SIZE
- i_size
);
1946 EXT4_I(inode
)->i_inline_size
= i_size
<
1947 EXT4_MIN_INLINE_DATA_SIZE
?
1948 EXT4_MIN_INLINE_DATA_SIZE
: i_size
;
1952 up_write(&EXT4_I(inode
)->i_data_sem
);
1955 up_write(&EXT4_I(inode
)->xattr_sem
);
1958 ext4_orphan_del(handle
, inode
);
1960 inode
->i_mtime
= inode
->i_ctime
= ext4_current_time(inode
);
1961 ext4_mark_inode_dirty(handle
, inode
);
1963 ext4_handle_sync(handle
);
1965 ext4_journal_stop(handle
);
1969 int ext4_convert_inline_data(struct inode
*inode
)
1971 int error
, needed_blocks
;
1973 struct ext4_iloc iloc
;
1975 if (!ext4_has_inline_data(inode
)) {
1976 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1980 needed_blocks
= ext4_writepage_trans_blocks(inode
);
1983 error
= ext4_get_inode_loc(inode
, &iloc
);
1987 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
1988 if (IS_ERR(handle
)) {
1989 error
= PTR_ERR(handle
);
1993 down_write(&EXT4_I(inode
)->xattr_sem
);
1994 if (!ext4_has_inline_data(inode
)) {
1995 up_write(&EXT4_I(inode
)->xattr_sem
);
1999 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
2000 up_write(&EXT4_I(inode
)->xattr_sem
);
2002 ext4_journal_stop(handle
);