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"
21 #include <trace/events/android_fs.h>
23 #define EXT4_XATTR_SYSTEM_DATA "data"
24 #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS))
25 #define EXT4_INLINE_DOTDOT_OFFSET 2
26 #define EXT4_INLINE_DOTDOT_SIZE 4
28 static int ext4_get_inline_size(struct inode
*inode
)
30 if (EXT4_I(inode
)->i_inline_off
)
31 return EXT4_I(inode
)->i_inline_size
;
36 static int get_max_inline_xattr_value_size(struct inode
*inode
,
37 struct ext4_iloc
*iloc
)
39 struct ext4_xattr_ibody_header
*header
;
40 struct ext4_xattr_entry
*entry
;
41 struct ext4_inode
*raw_inode
;
44 min_offs
= EXT4_SB(inode
->i_sb
)->s_inode_size
-
45 EXT4_GOOD_OLD_INODE_SIZE
-
46 EXT4_I(inode
)->i_extra_isize
-
47 sizeof(struct ext4_xattr_ibody_header
);
50 * We need to subtract another sizeof(__u32) since an in-inode xattr
51 * needs an empty 4 bytes to indicate the gap between the xattr entry
52 * and the name/value pair.
54 if (!ext4_test_inode_state(inode
, EXT4_STATE_XATTR
))
55 return EXT4_XATTR_SIZE(min_offs
-
56 EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
)) -
57 EXT4_XATTR_ROUND
- sizeof(__u32
));
59 raw_inode
= ext4_raw_inode(iloc
);
60 header
= IHDR(inode
, raw_inode
);
61 entry
= IFIRST(header
);
63 /* Compute min_offs. */
64 for (; !IS_LAST_ENTRY(entry
); entry
= EXT4_XATTR_NEXT(entry
)) {
65 if (!entry
->e_value_inum
&& entry
->e_value_size
) {
66 size_t offs
= le16_to_cpu(entry
->e_value_offs
);
72 ((void *)entry
- (void *)IFIRST(header
)) - sizeof(__u32
);
74 if (EXT4_I(inode
)->i_inline_off
) {
75 entry
= (struct ext4_xattr_entry
*)
76 ((void *)raw_inode
+ EXT4_I(inode
)->i_inline_off
);
78 free
+= EXT4_XATTR_SIZE(le32_to_cpu(entry
->e_value_size
));
82 free
-= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA
));
84 if (free
> EXT4_XATTR_ROUND
)
85 free
= EXT4_XATTR_SIZE(free
- EXT4_XATTR_ROUND
);
94 * Get the maximum size we now can store in an inode.
95 * If we can't find the space for a xattr entry, don't use the space
96 * of the extents since we have no space to indicate the inline data.
98 int ext4_get_max_inline_size(struct inode
*inode
)
100 int error
, max_inline_size
;
101 struct ext4_iloc iloc
;
103 if (EXT4_I(inode
)->i_extra_isize
== 0)
106 error
= ext4_get_inode_loc(inode
, &iloc
);
108 ext4_error_inode(inode
, __func__
, __LINE__
, 0,
109 "can't get inode location %lu",
114 down_read(&EXT4_I(inode
)->xattr_sem
);
115 max_inline_size
= get_max_inline_xattr_value_size(inode
, &iloc
);
116 up_read(&EXT4_I(inode
)->xattr_sem
);
120 if (!max_inline_size
)
123 return max_inline_size
+ EXT4_MIN_INLINE_DATA_SIZE
;
127 * this function does not take xattr_sem, which is OK because it is
128 * currently only used in a code path coming form ext4_iget, before
129 * the new inode has been unlocked
131 int ext4_find_inline_data_nolock(struct inode
*inode
)
133 struct ext4_xattr_ibody_find is
= {
134 .s
= { .not_found
= -ENODATA
, },
136 struct ext4_xattr_info i
= {
137 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
138 .name
= EXT4_XATTR_SYSTEM_DATA
,
142 if (EXT4_I(inode
)->i_extra_isize
== 0)
145 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
149 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
153 if (!is
.s
.not_found
) {
154 if (is
.s
.here
->e_value_inum
) {
155 EXT4_ERROR_INODE(inode
, "inline data xattr refers "
156 "to an external xattr inode");
157 error
= -EFSCORRUPTED
;
160 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
161 (void *)ext4_raw_inode(&is
.iloc
));
162 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
163 le32_to_cpu(is
.s
.here
->e_value_size
);
164 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
171 static int ext4_read_inline_data(struct inode
*inode
, void *buffer
,
173 struct ext4_iloc
*iloc
)
175 struct ext4_xattr_entry
*entry
;
176 struct ext4_xattr_ibody_header
*header
;
178 struct ext4_inode
*raw_inode
;
183 BUG_ON(len
> EXT4_I(inode
)->i_inline_size
);
185 cp_len
= len
< EXT4_MIN_INLINE_DATA_SIZE
?
186 len
: EXT4_MIN_INLINE_DATA_SIZE
;
188 raw_inode
= ext4_raw_inode(iloc
);
189 memcpy(buffer
, (void *)(raw_inode
->i_block
), cp_len
);
197 header
= IHDR(inode
, raw_inode
);
198 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
199 EXT4_I(inode
)->i_inline_off
);
200 len
= min_t(unsigned int, len
,
201 (unsigned int)le32_to_cpu(entry
->e_value_size
));
204 (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
), len
);
212 * write the buffer to the inline inode.
213 * If 'create' is set, we don't need to do the extra copy in the xattr
214 * value since it is already handled by ext4_xattr_ibody_inline_set.
215 * That saves us one memcpy.
217 static void ext4_write_inline_data(struct inode
*inode
, struct ext4_iloc
*iloc
,
218 void *buffer
, loff_t pos
, unsigned int len
)
220 struct ext4_xattr_entry
*entry
;
221 struct ext4_xattr_ibody_header
*header
;
222 struct ext4_inode
*raw_inode
;
225 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
228 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
229 BUG_ON(pos
+ len
> EXT4_I(inode
)->i_inline_size
);
231 raw_inode
= ext4_raw_inode(iloc
);
234 if (pos
< EXT4_MIN_INLINE_DATA_SIZE
) {
235 cp_len
= pos
+ len
> EXT4_MIN_INLINE_DATA_SIZE
?
236 EXT4_MIN_INLINE_DATA_SIZE
- pos
: len
;
237 memcpy((void *)raw_inode
->i_block
+ pos
, buffer
, cp_len
);
247 pos
-= EXT4_MIN_INLINE_DATA_SIZE
;
248 header
= IHDR(inode
, raw_inode
);
249 entry
= (struct ext4_xattr_entry
*)((void *)raw_inode
+
250 EXT4_I(inode
)->i_inline_off
);
252 memcpy((void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
) + pos
,
256 static int ext4_create_inline_data(handle_t
*handle
,
257 struct inode
*inode
, unsigned len
)
261 struct ext4_xattr_ibody_find is
= {
262 .s
= { .not_found
= -ENODATA
, },
264 struct ext4_xattr_info i
= {
265 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
266 .name
= EXT4_XATTR_SYSTEM_DATA
,
269 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
273 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
274 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
278 if (len
> EXT4_MIN_INLINE_DATA_SIZE
) {
279 value
= EXT4_ZERO_XATTR_VALUE
;
280 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
286 /* Insert the the xttr entry. */
290 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
294 BUG_ON(!is
.s
.not_found
);
296 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
298 if (error
== -ENOSPC
)
299 ext4_clear_inode_state(inode
,
300 EXT4_STATE_MAY_INLINE_DATA
);
304 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
305 0, EXT4_MIN_INLINE_DATA_SIZE
);
307 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
308 (void *)ext4_raw_inode(&is
.iloc
));
309 EXT4_I(inode
)->i_inline_size
= len
+ EXT4_MIN_INLINE_DATA_SIZE
;
310 ext4_clear_inode_flag(inode
, EXT4_INODE_EXTENTS
);
311 ext4_set_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
313 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
320 static int ext4_update_inline_data(handle_t
*handle
, struct inode
*inode
,
325 struct ext4_xattr_ibody_find is
= {
326 .s
= { .not_found
= -ENODATA
, },
328 struct ext4_xattr_info i
= {
329 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
330 .name
= EXT4_XATTR_SYSTEM_DATA
,
333 /* If the old space is ok, write the data directly. */
334 if (len
<= EXT4_I(inode
)->i_inline_size
)
337 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
341 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
345 BUG_ON(is
.s
.not_found
);
347 len
-= EXT4_MIN_INLINE_DATA_SIZE
;
348 value
= kzalloc(len
, GFP_NOFS
);
354 error
= ext4_xattr_ibody_get(inode
, i
.name_index
, i
.name
,
356 if (error
== -ENODATA
)
359 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
360 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
364 /* Update the xttr entry. */
368 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
372 EXT4_I(inode
)->i_inline_off
= (u16
)((void *)is
.s
.here
-
373 (void *)ext4_raw_inode(&is
.iloc
));
374 EXT4_I(inode
)->i_inline_size
= EXT4_MIN_INLINE_DATA_SIZE
+
375 le32_to_cpu(is
.s
.here
->e_value_size
);
376 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
378 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
386 static int ext4_prepare_inline_data(handle_t
*handle
, struct inode
*inode
,
389 int ret
, size
, no_expand
;
390 struct ext4_inode_info
*ei
= EXT4_I(inode
);
392 if (!ext4_test_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
))
395 size
= ext4_get_max_inline_size(inode
);
399 ext4_write_lock_xattr(inode
, &no_expand
);
401 if (ei
->i_inline_off
)
402 ret
= ext4_update_inline_data(handle
, inode
, len
);
404 ret
= ext4_create_inline_data(handle
, inode
, len
);
406 ext4_write_unlock_xattr(inode
, &no_expand
);
410 static int ext4_destroy_inline_data_nolock(handle_t
*handle
,
413 struct ext4_inode_info
*ei
= EXT4_I(inode
);
414 struct ext4_xattr_ibody_find is
= {
415 .s
= { .not_found
= 0, },
417 struct ext4_xattr_info i
= {
418 .name_index
= EXT4_XATTR_INDEX_SYSTEM
,
419 .name
= EXT4_XATTR_SYSTEM_DATA
,
425 if (!ei
->i_inline_off
)
428 error
= ext4_get_inode_loc(inode
, &is
.iloc
);
432 error
= ext4_xattr_ibody_find(inode
, &i
, &is
);
436 BUFFER_TRACE(is
.iloc
.bh
, "get_write_access");
437 error
= ext4_journal_get_write_access(handle
, is
.iloc
.bh
);
441 error
= ext4_xattr_ibody_inline_set(handle
, inode
, &i
, &is
);
445 memset((void *)ext4_raw_inode(&is
.iloc
)->i_block
,
446 0, EXT4_MIN_INLINE_DATA_SIZE
);
447 memset(ei
->i_data
, 0, EXT4_MIN_INLINE_DATA_SIZE
);
449 if (ext4_has_feature_extents(inode
->i_sb
)) {
450 if (S_ISDIR(inode
->i_mode
) ||
451 S_ISREG(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) {
452 ext4_set_inode_flag(inode
, EXT4_INODE_EXTENTS
);
453 ext4_ext_tree_init(handle
, inode
);
456 ext4_clear_inode_flag(inode
, EXT4_INODE_INLINE_DATA
);
459 error
= ext4_mark_iloc_dirty(handle
, inode
, &is
.iloc
);
461 EXT4_I(inode
)->i_inline_off
= 0;
462 EXT4_I(inode
)->i_inline_size
= 0;
463 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
466 if (error
== -ENODATA
)
471 static int ext4_read_inline_page(struct inode
*inode
, struct page
*page
)
476 struct ext4_iloc iloc
;
478 BUG_ON(!PageLocked(page
));
479 BUG_ON(!ext4_has_inline_data(inode
));
482 if (!EXT4_I(inode
)->i_inline_off
) {
483 ext4_warning(inode
->i_sb
, "inode %lu doesn't have inline data.",
488 ret
= ext4_get_inode_loc(inode
, &iloc
);
492 len
= min_t(size_t, ext4_get_inline_size(inode
), i_size_read(inode
));
493 kaddr
= kmap_atomic(page
);
494 ret
= ext4_read_inline_data(inode
, kaddr
, len
, &iloc
);
495 flush_dcache_page(page
);
496 kunmap_atomic(kaddr
);
497 zero_user_segment(page
, len
, PAGE_SIZE
);
498 SetPageUptodate(page
);
505 int ext4_readpage_inline(struct inode
*inode
, struct page
*page
)
509 down_read(&EXT4_I(inode
)->xattr_sem
);
510 if (!ext4_has_inline_data(inode
)) {
511 up_read(&EXT4_I(inode
)->xattr_sem
);
515 if (trace_android_fs_dataread_start_enabled()) {
516 char *path
, pathbuf
[MAX_TRACE_PATHBUF_LEN
];
518 path
= android_fstrace_get_pathname(pathbuf
,
519 MAX_TRACE_PATHBUF_LEN
,
521 trace_android_fs_dataread_start(inode
, page_offset(page
),
522 PAGE_SIZE
, current
->pid
,
523 path
, current
->comm
);
527 * Current inline data can only exist in the 1st page,
528 * So for all the other pages, just set them uptodate.
531 ret
= ext4_read_inline_page(inode
, page
);
532 else if (!PageUptodate(page
)) {
533 zero_user_segment(page
, 0, PAGE_SIZE
);
534 SetPageUptodate(page
);
537 trace_android_fs_dataread_end(inode
, page_offset(page
), PAGE_SIZE
);
539 up_read(&EXT4_I(inode
)->xattr_sem
);
542 return ret
>= 0 ? 0 : ret
;
545 static int ext4_convert_inline_data_to_extent(struct address_space
*mapping
,
549 int ret
, needed_blocks
, no_expand
;
550 handle_t
*handle
= NULL
;
551 int retries
= 0, sem_held
= 0;
552 struct page
*page
= NULL
;
554 struct ext4_iloc iloc
;
556 if (!ext4_has_inline_data(inode
)) {
558 * clear the flag so that no new write
559 * will trap here again.
561 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
565 needed_blocks
= ext4_writepage_trans_blocks(inode
);
567 ret
= ext4_get_inode_loc(inode
, &iloc
);
572 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
573 if (IS_ERR(handle
)) {
574 ret
= PTR_ERR(handle
);
579 /* We cannot recurse into the filesystem as the transaction is already
581 flags
|= AOP_FLAG_NOFS
;
583 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
589 ext4_write_lock_xattr(inode
, &no_expand
);
591 /* If some one has already done this for us, just exit. */
592 if (!ext4_has_inline_data(inode
)) {
598 to
= ext4_get_inline_size(inode
);
599 if (!PageUptodate(page
)) {
600 ret
= ext4_read_inline_page(inode
, page
);
605 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
609 if (ext4_should_dioread_nolock(inode
)) {
610 ret
= __block_write_begin(page
, from
, to
,
611 ext4_get_block_unwritten
);
613 ret
= __block_write_begin(page
, from
, to
, ext4_get_block
);
615 if (!ret
&& ext4_should_journal_data(inode
)) {
616 ret
= ext4_walk_page_buffers(handle
, page_buffers(page
),
618 do_journal_get_write_access
);
625 ext4_orphan_add(handle
, inode
);
626 ext4_write_unlock_xattr(inode
, &no_expand
);
628 ext4_journal_stop(handle
);
630 ext4_truncate_failed_write(inode
);
632 * If truncate failed early the inode might
633 * still be on the orphan list; we need to
634 * make sure the inode is removed from the
635 * orphan list in that case.
638 ext4_orphan_del(NULL
, inode
);
641 if (ret
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
645 block_commit_write(page
, from
, to
);
652 ext4_write_unlock_xattr(inode
, &no_expand
);
654 ext4_journal_stop(handle
);
660 * Try to write data in the inode.
661 * If the inode has inline data, check whether the new write can be
662 * in the inode also. If not, create the page the handle, move the data
663 * to the page make it update and let the later codes create extent for it.
665 int ext4_try_to_write_inline_data(struct address_space
*mapping
,
667 loff_t pos
, unsigned len
,
674 struct ext4_iloc iloc
;
676 if (pos
+ len
> ext4_get_max_inline_size(inode
))
679 ret
= ext4_get_inode_loc(inode
, &iloc
);
684 * The possible write could happen in the inode,
685 * so try to reserve the space in inode first.
687 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
688 if (IS_ERR(handle
)) {
689 ret
= PTR_ERR(handle
);
694 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
695 if (ret
&& ret
!= -ENOSPC
)
698 /* We don't have space in inline inode, so convert it to extent. */
699 if (ret
== -ENOSPC
) {
700 ext4_journal_stop(handle
);
705 ret
= ext4_journal_get_write_access(handle
, iloc
.bh
);
709 flags
|= AOP_FLAG_NOFS
;
711 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
718 down_read(&EXT4_I(inode
)->xattr_sem
);
719 if (!ext4_has_inline_data(inode
)) {
726 if (!PageUptodate(page
)) {
727 ret
= ext4_read_inline_page(inode
, page
);
738 up_read(&EXT4_I(inode
)->xattr_sem
);
740 if (handle
&& (ret
!= 1))
741 ext4_journal_stop(handle
);
745 return ext4_convert_inline_data_to_extent(mapping
,
749 int ext4_write_inline_data_end(struct inode
*inode
, loff_t pos
, unsigned len
,
750 unsigned copied
, struct page
*page
)
754 struct ext4_iloc iloc
;
756 if (unlikely(copied
< len
)) {
757 if (!PageUptodate(page
)) {
763 ret
= ext4_get_inode_loc(inode
, &iloc
);
765 ext4_std_error(inode
->i_sb
, ret
);
770 ext4_write_lock_xattr(inode
, &no_expand
);
771 BUG_ON(!ext4_has_inline_data(inode
));
773 kaddr
= kmap_atomic(page
);
774 ext4_write_inline_data(inode
, &iloc
, kaddr
, pos
, len
);
775 kunmap_atomic(kaddr
);
776 SetPageUptodate(page
);
777 /* clear page dirty so that writepages wouldn't work for us. */
778 ClearPageDirty(page
);
780 ext4_write_unlock_xattr(inode
, &no_expand
);
782 mark_inode_dirty(inode
);
788 ext4_journalled_write_inline_data(struct inode
*inode
,
794 struct ext4_iloc iloc
;
796 ret
= ext4_get_inode_loc(inode
, &iloc
);
798 ext4_std_error(inode
->i_sb
, ret
);
802 ext4_write_lock_xattr(inode
, &no_expand
);
803 kaddr
= kmap_atomic(page
);
804 ext4_write_inline_data(inode
, &iloc
, kaddr
, 0, len
);
805 kunmap_atomic(kaddr
);
806 ext4_write_unlock_xattr(inode
, &no_expand
);
812 * Try to make the page cache and handle ready for the inline data case.
813 * We can call this function in 2 cases:
814 * 1. The inode is created and the first write exceeds inline size. We can
815 * clear the inode state safely.
816 * 2. The inode has inline data, then we need to read the data, make it
817 * update and dirty so that ext4_da_writepages can handle it. We don't
818 * need to start the journal since the file's metatdata isn't changed now.
820 static int ext4_da_convert_inline_data_to_extent(struct address_space
*mapping
,
825 int ret
= 0, inline_size
;
828 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
832 down_read(&EXT4_I(inode
)->xattr_sem
);
833 if (!ext4_has_inline_data(inode
)) {
834 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
838 inline_size
= ext4_get_inline_size(inode
);
840 if (!PageUptodate(page
)) {
841 ret
= ext4_read_inline_page(inode
, page
);
846 ret
= __block_write_begin(page
, 0, inline_size
,
847 ext4_da_get_block_prep
);
849 up_read(&EXT4_I(inode
)->xattr_sem
);
852 ext4_truncate_failed_write(inode
);
857 SetPageUptodate(page
);
858 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
859 *fsdata
= (void *)CONVERT_INLINE_DATA
;
862 up_read(&EXT4_I(inode
)->xattr_sem
);
871 * Prepare the write for the inline data.
872 * If the the data can be written into the inode, we just read
873 * the page and make it uptodate, and start the journal.
874 * Otherwise read the page, makes it dirty so that it can be
875 * handle in writepages(the i_disksize update is left to the
876 * normal ext4_da_write_end).
878 int ext4_da_write_inline_data_begin(struct address_space
*mapping
,
880 loff_t pos
, unsigned len
,
885 int ret
, inline_size
;
888 struct ext4_iloc iloc
;
891 ret
= ext4_get_inode_loc(inode
, &iloc
);
896 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 1);
897 if (IS_ERR(handle
)) {
898 ret
= PTR_ERR(handle
);
902 inline_size
= ext4_get_max_inline_size(inode
);
905 if (inline_size
>= pos
+ len
) {
906 ret
= ext4_prepare_inline_data(handle
, inode
, pos
+ len
);
907 if (ret
&& ret
!= -ENOSPC
)
912 * We cannot recurse into the filesystem as the transaction
913 * is already started.
915 flags
|= AOP_FLAG_NOFS
;
917 if (ret
== -ENOSPC
) {
918 ext4_journal_stop(handle
);
919 ret
= ext4_da_convert_inline_data_to_extent(mapping
,
923 if (ret
== -ENOSPC
&&
924 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
929 page
= grab_cache_page_write_begin(mapping
, 0, flags
);
935 down_read(&EXT4_I(inode
)->xattr_sem
);
936 if (!ext4_has_inline_data(inode
)) {
938 goto out_release_page
;
941 if (!PageUptodate(page
)) {
942 ret
= ext4_read_inline_page(inode
, page
);
944 goto out_release_page
;
946 ret
= ext4_journal_get_write_access(handle
, iloc
.bh
);
948 goto out_release_page
;
950 up_read(&EXT4_I(inode
)->xattr_sem
);
955 up_read(&EXT4_I(inode
)->xattr_sem
);
959 ext4_journal_stop(handle
);
965 int ext4_da_write_inline_data_end(struct inode
*inode
, loff_t pos
,
966 unsigned len
, unsigned copied
,
971 ret
= ext4_write_inline_data_end(inode
, pos
, len
, copied
, page
);
980 * No need to use i_size_read() here, the i_size
981 * cannot change under us because we hold i_mutex.
983 * But it's important to update i_size while still holding page lock:
984 * page writeout could otherwise come in and zero beyond i_size.
986 if (pos
+copied
> inode
->i_size
)
987 i_size_write(inode
, pos
+copied
);
992 * Don't mark the inode dirty under page lock. First, it unnecessarily
993 * makes the holding time of page lock longer. Second, it forces lock
994 * ordering of page lock and transaction start for journaling
997 mark_inode_dirty(inode
);
1002 #ifdef INLINE_DIR_DEBUG
1003 void ext4_show_inline_dir(struct inode
*dir
, struct buffer_head
*bh
,
1004 void *inline_start
, int inline_size
)
1007 unsigned short de_len
;
1008 struct ext4_dir_entry_2
*de
= inline_start
;
1009 void *dlimit
= inline_start
+ inline_size
;
1011 trace_printk("inode %lu\n", dir
->i_ino
);
1013 while ((void *)de
< dlimit
) {
1014 de_len
= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1015 trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
1016 offset
, de_len
, de
->name_len
, de
->name
,
1017 de
->name_len
, le32_to_cpu(de
->inode
));
1018 if (ext4_check_dir_entry(dir
, NULL
, de
, bh
,
1019 inline_start
, inline_size
, offset
))
1023 de
= (struct ext4_dir_entry_2
*) ((char *) de
+ de_len
);
1027 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
1031 * Add a new entry into a inline dir.
1032 * It will return -ENOSPC if no space is available, and -EIO
1033 * and -EEXIST if directory entry already exists.
1035 static int ext4_add_dirent_to_inline(handle_t
*handle
,
1036 struct ext4_filename
*fname
,
1038 struct inode
*inode
,
1039 struct ext4_iloc
*iloc
,
1040 void *inline_start
, int inline_size
)
1043 struct ext4_dir_entry_2
*de
;
1045 err
= ext4_find_dest_de(dir
, inode
, iloc
->bh
, inline_start
,
1046 inline_size
, fname
, &de
);
1050 BUFFER_TRACE(iloc
->bh
, "get_write_access");
1051 err
= ext4_journal_get_write_access(handle
, iloc
->bh
);
1054 ext4_insert_dentry(inode
, de
, inline_size
, fname
);
1056 ext4_show_inline_dir(dir
, iloc
->bh
, inline_start
, inline_size
);
1059 * XXX shouldn't update any times until successful
1060 * completion of syscall, but too many callers depend
1063 * XXX similarly, too many callers depend on
1064 * ext4_new_inode() setting the times, but error
1065 * recovery deletes the inode, so the worst that can
1066 * happen is that the times are slightly out of date
1067 * and/or different from the directory change time.
1069 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1070 ext4_update_dx_flag(dir
);
1075 static void *ext4_get_inline_xattr_pos(struct inode
*inode
,
1076 struct ext4_iloc
*iloc
)
1078 struct ext4_xattr_entry
*entry
;
1079 struct ext4_xattr_ibody_header
*header
;
1081 BUG_ON(!EXT4_I(inode
)->i_inline_off
);
1083 header
= IHDR(inode
, ext4_raw_inode(iloc
));
1084 entry
= (struct ext4_xattr_entry
*)((void *)ext4_raw_inode(iloc
) +
1085 EXT4_I(inode
)->i_inline_off
);
1087 return (void *)IFIRST(header
) + le16_to_cpu(entry
->e_value_offs
);
1090 /* Set the final de to cover the whole block. */
1091 static void ext4_update_final_de(void *de_buf
, int old_size
, int new_size
)
1093 struct ext4_dir_entry_2
*de
, *prev_de
;
1097 de
= (struct ext4_dir_entry_2
*)de_buf
;
1099 limit
= de_buf
+ old_size
;
1102 de_len
= ext4_rec_len_from_disk(de
->rec_len
, old_size
);
1104 de
= (struct ext4_dir_entry_2
*)de_buf
;
1105 } while (de_buf
< limit
);
1107 prev_de
->rec_len
= ext4_rec_len_to_disk(de_len
+ new_size
-
1108 old_size
, new_size
);
1110 /* this is just created, so create an empty entry. */
1112 de
->rec_len
= ext4_rec_len_to_disk(new_size
, new_size
);
1116 static int ext4_update_inline_dir(handle_t
*handle
, struct inode
*dir
,
1117 struct ext4_iloc
*iloc
)
1120 int old_size
= EXT4_I(dir
)->i_inline_size
- EXT4_MIN_INLINE_DATA_SIZE
;
1121 int new_size
= get_max_inline_xattr_value_size(dir
, iloc
);
1123 if (new_size
- old_size
<= EXT4_DIR_REC_LEN(1))
1126 ret
= ext4_update_inline_data(handle
, dir
,
1127 new_size
+ EXT4_MIN_INLINE_DATA_SIZE
);
1131 ext4_update_final_de(ext4_get_inline_xattr_pos(dir
, iloc
), old_size
,
1132 EXT4_I(dir
)->i_inline_size
-
1133 EXT4_MIN_INLINE_DATA_SIZE
);
1134 dir
->i_size
= EXT4_I(dir
)->i_disksize
= EXT4_I(dir
)->i_inline_size
;
1138 static void ext4_restore_inline_data(handle_t
*handle
, struct inode
*inode
,
1139 struct ext4_iloc
*iloc
,
1140 void *buf
, int inline_size
)
1142 ext4_create_inline_data(handle
, inode
, inline_size
);
1143 ext4_write_inline_data(inode
, iloc
, buf
, 0, inline_size
);
1144 ext4_set_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1147 static int ext4_finish_convert_inline_dir(handle_t
*handle
,
1148 struct inode
*inode
,
1149 struct buffer_head
*dir_block
,
1153 int err
, csum_size
= 0, header_size
= 0;
1154 struct ext4_dir_entry_2
*de
;
1155 struct ext4_dir_entry_tail
*t
;
1156 void *target
= dir_block
->b_data
;
1159 * First create "." and ".." and then copy the dir information
1160 * back to the block.
1162 de
= (struct ext4_dir_entry_2
*)target
;
1163 de
= ext4_init_dot_dotdot(inode
, de
,
1164 inode
->i_sb
->s_blocksize
, csum_size
,
1165 le32_to_cpu(((struct ext4_dir_entry_2
*)buf
)->inode
), 1);
1166 header_size
= (void *)de
- target
;
1168 memcpy((void *)de
, buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1169 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1171 if (ext4_has_metadata_csum(inode
->i_sb
))
1172 csum_size
= sizeof(struct ext4_dir_entry_tail
);
1174 inode
->i_size
= inode
->i_sb
->s_blocksize
;
1175 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
1176 EXT4_I(inode
)->i_disksize
= inode
->i_sb
->s_blocksize
;
1177 ext4_update_final_de(dir_block
->b_data
,
1178 inline_size
- EXT4_INLINE_DOTDOT_SIZE
+ header_size
,
1179 inode
->i_sb
->s_blocksize
- csum_size
);
1182 t
= EXT4_DIRENT_TAIL(dir_block
->b_data
,
1183 inode
->i_sb
->s_blocksize
);
1184 initialize_dirent_tail(t
, inode
->i_sb
->s_blocksize
);
1186 set_buffer_uptodate(dir_block
);
1187 err
= ext4_handle_dirty_dirent_node(handle
, inode
, dir_block
);
1190 set_buffer_verified(dir_block
);
1191 return ext4_mark_inode_dirty(handle
, inode
);
1194 static int ext4_convert_inline_data_nolock(handle_t
*handle
,
1195 struct inode
*inode
,
1196 struct ext4_iloc
*iloc
)
1200 struct buffer_head
*data_bh
= NULL
;
1201 struct ext4_map_blocks map
;
1204 inline_size
= ext4_get_inline_size(inode
);
1205 buf
= kmalloc(inline_size
, GFP_NOFS
);
1211 error
= ext4_read_inline_data(inode
, buf
, inline_size
, iloc
);
1216 * Make sure the inline directory entries pass checks before we try to
1217 * convert them, so that we avoid touching stuff that needs fsck.
1219 if (S_ISDIR(inode
->i_mode
)) {
1220 error
= ext4_check_all_de(inode
, iloc
->bh
,
1221 buf
+ EXT4_INLINE_DOTDOT_SIZE
,
1222 inline_size
- EXT4_INLINE_DOTDOT_SIZE
);
1227 error
= ext4_destroy_inline_data_nolock(handle
, inode
);
1234 error
= ext4_map_blocks(handle
, inode
, &map
, EXT4_GET_BLOCKS_CREATE
);
1237 if (!(map
.m_flags
& EXT4_MAP_MAPPED
)) {
1242 data_bh
= sb_getblk(inode
->i_sb
, map
.m_pblk
);
1248 lock_buffer(data_bh
);
1249 error
= ext4_journal_get_create_access(handle
, 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
, 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 ext4_mark_inode_dirty(handle
, dir
);
1346 * This function fills a red-black tree with information from an
1347 * inlined dir. It returns the number directory entries loaded
1348 * into the tree. If there is an error it is returned in err.
1350 int htree_inlinedir_to_tree(struct file
*dir_file
,
1351 struct inode
*dir
, ext4_lblk_t block
,
1352 struct dx_hash_info
*hinfo
,
1353 __u32 start_hash
, __u32 start_minor_hash
,
1354 int *has_inline_data
)
1356 int err
= 0, count
= 0;
1357 unsigned int parent_ino
;
1359 struct ext4_dir_entry_2
*de
;
1360 struct inode
*inode
= file_inode(dir_file
);
1361 int ret
, inline_size
= 0;
1362 struct ext4_iloc iloc
;
1363 void *dir_buf
= NULL
;
1364 struct ext4_dir_entry_2 fake
;
1365 struct fscrypt_str tmp_str
;
1367 ret
= ext4_get_inode_loc(inode
, &iloc
);
1371 down_read(&EXT4_I(inode
)->xattr_sem
);
1372 if (!ext4_has_inline_data(inode
)) {
1373 up_read(&EXT4_I(inode
)->xattr_sem
);
1374 *has_inline_data
= 0;
1378 inline_size
= ext4_get_inline_size(inode
);
1379 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1382 up_read(&EXT4_I(inode
)->xattr_sem
);
1386 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1387 up_read(&EXT4_I(inode
)->xattr_sem
);
1392 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1393 while (pos
< inline_size
) {
1395 * As inlined dir doesn't store any information about '.' and
1396 * only the inode number of '..' is stored, we have to handle
1400 fake
.inode
= cpu_to_le32(inode
->i_ino
);
1402 strcpy(fake
.name
, ".");
1403 fake
.rec_len
= ext4_rec_len_to_disk(
1404 EXT4_DIR_REC_LEN(fake
.name_len
),
1406 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1408 pos
= EXT4_INLINE_DOTDOT_OFFSET
;
1409 } else if (pos
== EXT4_INLINE_DOTDOT_OFFSET
) {
1410 fake
.inode
= cpu_to_le32(parent_ino
);
1412 strcpy(fake
.name
, "..");
1413 fake
.rec_len
= ext4_rec_len_to_disk(
1414 EXT4_DIR_REC_LEN(fake
.name_len
),
1416 ext4_set_de_type(inode
->i_sb
, &fake
, S_IFDIR
);
1418 pos
= EXT4_INLINE_DOTDOT_SIZE
;
1420 de
= (struct ext4_dir_entry_2
*)(dir_buf
+ pos
);
1421 pos
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1422 if (ext4_check_dir_entry(inode
, dir_file
, de
,
1424 inline_size
, pos
)) {
1430 ext4fs_dirhash(de
->name
, de
->name_len
, hinfo
);
1431 if ((hinfo
->hash
< start_hash
) ||
1432 ((hinfo
->hash
== start_hash
) &&
1433 (hinfo
->minor_hash
< start_minor_hash
)))
1437 tmp_str
.name
= de
->name
;
1438 tmp_str
.len
= de
->name_len
;
1439 err
= ext4_htree_store_dirent(dir_file
, hinfo
->hash
,
1440 hinfo
->minor_hash
, de
, &tmp_str
);
1455 * So this function is called when the volume is mkfsed with
1456 * dir_index disabled. In order to keep f_pos persistent
1457 * after we convert from an inlined dir to a blocked based,
1458 * we just pretend that we are a normal dir and return the
1459 * offset as if '.' and '..' really take place.
1462 int ext4_read_inline_dir(struct file
*file
,
1463 struct dir_context
*ctx
,
1464 int *has_inline_data
)
1466 unsigned int offset
, parent_ino
;
1468 struct ext4_dir_entry_2
*de
;
1469 struct super_block
*sb
;
1470 struct inode
*inode
= file_inode(file
);
1471 int ret
, inline_size
= 0;
1472 struct ext4_iloc iloc
;
1473 void *dir_buf
= NULL
;
1474 int dotdot_offset
, dotdot_size
, extra_offset
, extra_size
;
1476 ret
= ext4_get_inode_loc(inode
, &iloc
);
1480 down_read(&EXT4_I(inode
)->xattr_sem
);
1481 if (!ext4_has_inline_data(inode
)) {
1482 up_read(&EXT4_I(inode
)->xattr_sem
);
1483 *has_inline_data
= 0;
1487 inline_size
= ext4_get_inline_size(inode
);
1488 dir_buf
= kmalloc(inline_size
, GFP_NOFS
);
1491 up_read(&EXT4_I(inode
)->xattr_sem
);
1495 ret
= ext4_read_inline_data(inode
, dir_buf
, inline_size
, &iloc
);
1496 up_read(&EXT4_I(inode
)->xattr_sem
);
1502 parent_ino
= le32_to_cpu(((struct ext4_dir_entry_2
*)dir_buf
)->inode
);
1506 * dotdot_offset and dotdot_size is the real offset and
1507 * size for ".." and "." if the dir is block based while
1508 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1509 * So we will use extra_offset and extra_size to indicate them
1510 * during the inline dir iteration.
1512 dotdot_offset
= EXT4_DIR_REC_LEN(1);
1513 dotdot_size
= dotdot_offset
+ EXT4_DIR_REC_LEN(2);
1514 extra_offset
= dotdot_size
- EXT4_INLINE_DOTDOT_SIZE
;
1515 extra_size
= extra_offset
+ inline_size
;
1518 * If the version has changed since the last call to
1519 * readdir(2), then we might be pointing to an invalid
1520 * dirent right now. Scan from the start of the inline
1523 if (file
->f_version
!= inode
->i_version
) {
1524 for (i
= 0; i
< extra_size
&& i
< offset
;) {
1526 * "." is with offset 0 and
1527 * ".." is dotdot_offset.
1532 } else if (i
== dotdot_offset
) {
1536 /* for other entry, the real offset in
1537 * the buf has to be tuned accordingly.
1539 de
= (struct ext4_dir_entry_2
*)
1540 (dir_buf
+ i
- extra_offset
);
1541 /* It's too expensive to do a full
1542 * dirent test each time round this
1543 * loop, but we do have to test at
1544 * least that it is non-zero. A
1545 * failure will be detected in the
1546 * dirent test below. */
1547 if (ext4_rec_len_from_disk(de
->rec_len
, extra_size
)
1548 < EXT4_DIR_REC_LEN(1))
1550 i
+= ext4_rec_len_from_disk(de
->rec_len
,
1555 file
->f_version
= inode
->i_version
;
1558 while (ctx
->pos
< extra_size
) {
1559 if (ctx
->pos
== 0) {
1560 if (!dir_emit(ctx
, ".", 1, inode
->i_ino
, DT_DIR
))
1562 ctx
->pos
= dotdot_offset
;
1566 if (ctx
->pos
== dotdot_offset
) {
1567 if (!dir_emit(ctx
, "..", 2, parent_ino
, DT_DIR
))
1569 ctx
->pos
= dotdot_size
;
1573 de
= (struct ext4_dir_entry_2
*)
1574 (dir_buf
+ ctx
->pos
- extra_offset
);
1575 if (ext4_check_dir_entry(inode
, file
, de
, iloc
.bh
, dir_buf
,
1576 extra_size
, ctx
->pos
))
1578 if (le32_to_cpu(de
->inode
)) {
1579 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1580 le32_to_cpu(de
->inode
),
1581 get_dtype(sb
, de
->file_type
)))
1584 ctx
->pos
+= ext4_rec_len_from_disk(de
->rec_len
, extra_size
);
1592 struct buffer_head
*ext4_get_first_inline_block(struct inode
*inode
,
1593 struct ext4_dir_entry_2
**parent_de
,
1596 struct ext4_iloc iloc
;
1598 *retval
= ext4_get_inode_loc(inode
, &iloc
);
1602 *parent_de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1608 * Try to create the inline data for the new dir.
1609 * If it succeeds, return 0, otherwise return the error.
1610 * In case of ENOSPC, the caller should create the normal disk layout dir.
1612 int ext4_try_create_inline_dir(handle_t
*handle
, struct inode
*parent
,
1613 struct inode
*inode
)
1615 int ret
, inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1616 struct ext4_iloc iloc
;
1617 struct ext4_dir_entry_2
*de
;
1619 ret
= ext4_get_inode_loc(inode
, &iloc
);
1623 ret
= ext4_prepare_inline_data(handle
, inode
, inline_size
);
1628 * For inline dir, we only save the inode information for the ".."
1629 * and create a fake dentry to cover the left space.
1631 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1632 de
->inode
= cpu_to_le32(parent
->i_ino
);
1633 de
= (struct ext4_dir_entry_2
*)((void *)de
+ EXT4_INLINE_DOTDOT_SIZE
);
1635 de
->rec_len
= ext4_rec_len_to_disk(
1636 inline_size
- EXT4_INLINE_DOTDOT_SIZE
,
1638 set_nlink(inode
, 2);
1639 inode
->i_size
= EXT4_I(inode
)->i_disksize
= inline_size
;
1645 struct buffer_head
*ext4_find_inline_entry(struct inode
*dir
,
1646 struct ext4_filename
*fname
,
1647 struct ext4_dir_entry_2
**res_dir
,
1648 int *has_inline_data
)
1651 struct ext4_iloc iloc
;
1655 if (ext4_get_inode_loc(dir
, &iloc
))
1658 down_read(&EXT4_I(dir
)->xattr_sem
);
1659 if (!ext4_has_inline_data(dir
)) {
1660 *has_inline_data
= 0;
1664 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1665 EXT4_INLINE_DOTDOT_SIZE
;
1666 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
- EXT4_INLINE_DOTDOT_SIZE
;
1667 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1668 dir
, fname
, 0, res_dir
);
1674 if (ext4_get_inline_size(dir
) == EXT4_MIN_INLINE_DATA_SIZE
)
1677 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1678 inline_size
= ext4_get_inline_size(dir
) - EXT4_MIN_INLINE_DATA_SIZE
;
1680 ret
= ext4_search_dir(iloc
.bh
, inline_start
, inline_size
,
1681 dir
, fname
, 0, res_dir
);
1689 up_read(&EXT4_I(dir
)->xattr_sem
);
1693 int ext4_delete_inline_entry(handle_t
*handle
,
1695 struct ext4_dir_entry_2
*de_del
,
1696 struct buffer_head
*bh
,
1697 int *has_inline_data
)
1699 int err
, inline_size
, no_expand
;
1700 struct ext4_iloc iloc
;
1703 err
= ext4_get_inode_loc(dir
, &iloc
);
1707 ext4_write_lock_xattr(dir
, &no_expand
);
1708 if (!ext4_has_inline_data(dir
)) {
1709 *has_inline_data
= 0;
1713 if ((void *)de_del
- ((void *)ext4_raw_inode(&iloc
)->i_block
) <
1714 EXT4_MIN_INLINE_DATA_SIZE
) {
1715 inline_start
= (void *)ext4_raw_inode(&iloc
)->i_block
+
1716 EXT4_INLINE_DOTDOT_SIZE
;
1717 inline_size
= EXT4_MIN_INLINE_DATA_SIZE
-
1718 EXT4_INLINE_DOTDOT_SIZE
;
1720 inline_start
= ext4_get_inline_xattr_pos(dir
, &iloc
);
1721 inline_size
= ext4_get_inline_size(dir
) -
1722 EXT4_MIN_INLINE_DATA_SIZE
;
1725 BUFFER_TRACE(bh
, "get_write_access");
1726 err
= ext4_journal_get_write_access(handle
, bh
);
1730 err
= ext4_generic_delete_entry(handle
, dir
, de_del
, bh
,
1731 inline_start
, inline_size
, 0);
1735 ext4_show_inline_dir(dir
, iloc
.bh
, inline_start
, inline_size
);
1737 ext4_write_unlock_xattr(dir
, &no_expand
);
1738 if (likely(err
== 0))
1739 err
= ext4_mark_inode_dirty(handle
, dir
);
1742 ext4_std_error(dir
->i_sb
, err
);
1747 * Get the inline dentry at offset.
1749 static inline struct ext4_dir_entry_2
*
1750 ext4_get_inline_entry(struct inode
*inode
,
1751 struct ext4_iloc
*iloc
,
1752 unsigned int offset
,
1753 void **inline_start
,
1758 BUG_ON(offset
> ext4_get_inline_size(inode
));
1760 if (offset
< EXT4_MIN_INLINE_DATA_SIZE
) {
1761 inline_pos
= (void *)ext4_raw_inode(iloc
)->i_block
;
1762 *inline_size
= EXT4_MIN_INLINE_DATA_SIZE
;
1764 inline_pos
= ext4_get_inline_xattr_pos(inode
, iloc
);
1765 offset
-= EXT4_MIN_INLINE_DATA_SIZE
;
1766 *inline_size
= ext4_get_inline_size(inode
) -
1767 EXT4_MIN_INLINE_DATA_SIZE
;
1771 *inline_start
= inline_pos
;
1772 return (struct ext4_dir_entry_2
*)(inline_pos
+ offset
);
1775 bool empty_inline_dir(struct inode
*dir
, int *has_inline_data
)
1777 int err
, inline_size
;
1778 struct ext4_iloc iloc
;
1781 unsigned int offset
;
1782 struct ext4_dir_entry_2
*de
;
1785 err
= ext4_get_inode_loc(dir
, &iloc
);
1787 EXT4_ERROR_INODE(dir
, "error %d getting inode %lu block",
1792 down_read(&EXT4_I(dir
)->xattr_sem
);
1793 if (!ext4_has_inline_data(dir
)) {
1794 *has_inline_data
= 0;
1798 de
= (struct ext4_dir_entry_2
*)ext4_raw_inode(&iloc
)->i_block
;
1799 if (!le32_to_cpu(de
->inode
)) {
1800 ext4_warning(dir
->i_sb
,
1801 "bad inline directory (dir #%lu) - no `..'",
1807 inline_len
= ext4_get_inline_size(dir
);
1808 offset
= EXT4_INLINE_DOTDOT_SIZE
;
1809 while (offset
< inline_len
) {
1810 de
= ext4_get_inline_entry(dir
, &iloc
, offset
,
1811 &inline_pos
, &inline_size
);
1812 if (ext4_check_dir_entry(dir
, NULL
, de
,
1813 iloc
.bh
, inline_pos
,
1814 inline_size
, offset
)) {
1815 ext4_warning(dir
->i_sb
,
1816 "bad inline directory (dir #%lu) - "
1817 "inode %u, rec_len %u, name_len %d"
1819 dir
->i_ino
, le32_to_cpu(de
->inode
),
1820 le16_to_cpu(de
->rec_len
), de
->name_len
,
1825 if (le32_to_cpu(de
->inode
)) {
1829 offset
+= ext4_rec_len_from_disk(de
->rec_len
, inline_size
);
1833 up_read(&EXT4_I(dir
)->xattr_sem
);
1838 int ext4_destroy_inline_data(handle_t
*handle
, struct inode
*inode
)
1842 ext4_write_lock_xattr(inode
, &no_expand
);
1843 ret
= ext4_destroy_inline_data_nolock(handle
, inode
);
1844 ext4_write_unlock_xattr(inode
, &no_expand
);
1849 int ext4_inline_data_fiemap(struct inode
*inode
,
1850 struct fiemap_extent_info
*fieinfo
,
1851 int *has_inline
, __u64 start
, __u64 len
)
1855 __u32 flags
= FIEMAP_EXTENT_DATA_INLINE
| FIEMAP_EXTENT_NOT_ALIGNED
|
1858 struct ext4_iloc iloc
;
1860 down_read(&EXT4_I(inode
)->xattr_sem
);
1861 if (!ext4_has_inline_data(inode
)) {
1865 inline_len
= min_t(size_t, ext4_get_inline_size(inode
),
1866 i_size_read(inode
));
1867 if (start
>= inline_len
)
1869 if (start
+ len
< inline_len
)
1870 inline_len
= start
+ len
;
1871 inline_len
-= start
;
1873 error
= ext4_get_inode_loc(inode
, &iloc
);
1877 physical
= (__u64
)iloc
.bh
->b_blocknr
<< inode
->i_sb
->s_blocksize_bits
;
1878 physical
+= (char *)ext4_raw_inode(&iloc
) - iloc
.bh
->b_data
;
1879 physical
+= offsetof(struct ext4_inode
, i_block
);
1883 up_read(&EXT4_I(inode
)->xattr_sem
);
1885 error
= fiemap_fill_next_extent(fieinfo
, start
, physical
,
1887 return (error
< 0 ? error
: 0);
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
)) {
1913 ext4_journal_stop(handle
);
1917 if ((err
= ext4_orphan_add(handle
, inode
)) != 0)
1920 if ((err
= ext4_get_inode_loc(inode
, &is
.iloc
)) != 0)
1923 down_write(&EXT4_I(inode
)->i_data_sem
);
1924 i_size
= inode
->i_size
;
1925 inline_size
= ext4_get_inline_size(inode
);
1926 EXT4_I(inode
)->i_disksize
= i_size
;
1928 if (i_size
< inline_size
) {
1929 /* Clear the content in the xattr space. */
1930 if (inline_size
> EXT4_MIN_INLINE_DATA_SIZE
) {
1931 if ((err
= ext4_xattr_ibody_find(inode
, &i
, &is
)) != 0)
1934 BUG_ON(is
.s
.not_found
);
1936 value_len
= le32_to_cpu(is
.s
.here
->e_value_size
);
1937 value
= kmalloc(value_len
, GFP_NOFS
);
1943 err
= ext4_xattr_ibody_get(inode
, i
.name_index
,
1944 i
.name
, value
, value_len
);
1949 i
.value_len
= i_size
> EXT4_MIN_INLINE_DATA_SIZE
?
1950 i_size
- EXT4_MIN_INLINE_DATA_SIZE
: 0;
1951 err
= ext4_xattr_ibody_inline_set(handle
, inode
,
1957 /* Clear the content within i_blocks. */
1958 if (i_size
< EXT4_MIN_INLINE_DATA_SIZE
) {
1959 void *p
= (void *) ext4_raw_inode(&is
.iloc
)->i_block
;
1960 memset(p
+ i_size
, 0,
1961 EXT4_MIN_INLINE_DATA_SIZE
- i_size
);
1964 EXT4_I(inode
)->i_inline_size
= i_size
<
1965 EXT4_MIN_INLINE_DATA_SIZE
?
1966 EXT4_MIN_INLINE_DATA_SIZE
: i_size
;
1970 up_write(&EXT4_I(inode
)->i_data_sem
);
1973 ext4_write_unlock_xattr(inode
, &no_expand
);
1976 ext4_orphan_del(handle
, inode
);
1979 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1980 err
= ext4_mark_inode_dirty(handle
, inode
);
1982 ext4_handle_sync(handle
);
1984 ext4_journal_stop(handle
);
1988 int ext4_convert_inline_data(struct inode
*inode
)
1990 int error
, needed_blocks
, no_expand
;
1992 struct ext4_iloc iloc
;
1994 if (!ext4_has_inline_data(inode
)) {
1995 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
1999 needed_blocks
= ext4_writepage_trans_blocks(inode
);
2002 error
= ext4_get_inode_loc(inode
, &iloc
);
2006 handle
= ext4_journal_start(inode
, EXT4_HT_WRITE_PAGE
, needed_blocks
);
2007 if (IS_ERR(handle
)) {
2008 error
= PTR_ERR(handle
);
2012 ext4_write_lock_xattr(inode
, &no_expand
);
2013 if (ext4_has_inline_data(inode
))
2014 error
= ext4_convert_inline_data_nolock(handle
, inode
, &iloc
);
2015 ext4_write_unlock_xattr(inode
, &no_expand
);
2016 ext4_journal_stop(handle
);