xref: /openbmc/linux/fs/ext4/inline.c (revision 33ac9dba)
1 /*
2  * Copyright (c) 2012 Taobao.
3  * Written by Tao Ma <boyu.mt@taobao.com>
4  *
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.
8  *
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.
13  */
14 #include "ext4_jbd2.h"
15 #include "ext4.h"
16 #include "xattr.h"
17 #include "truncate.h"
18 #include <linux/fiemap.h>
19 
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
24 
25 static int ext4_get_inline_size(struct inode *inode)
26 {
27 	if (EXT4_I(inode)->i_inline_off)
28 		return EXT4_I(inode)->i_inline_size;
29 
30 	return 0;
31 }
32 
33 static int get_max_inline_xattr_value_size(struct inode *inode,
34 					   struct ext4_iloc *iloc)
35 {
36 	struct ext4_xattr_ibody_header *header;
37 	struct ext4_xattr_entry *entry;
38 	struct ext4_inode *raw_inode;
39 	int free, min_offs;
40 
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);
45 
46 	/*
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.
50 	 */
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));
55 
56 	raw_inode = ext4_raw_inode(iloc);
57 	header = IHDR(inode, raw_inode);
58 	entry = IFIRST(header);
59 
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);
64 			if (offs < min_offs)
65 				min_offs = offs;
66 		}
67 	}
68 	free = min_offs -
69 		((void *)entry - (void *)IFIRST(header)) - sizeof(__u32);
70 
71 	if (EXT4_I(inode)->i_inline_off) {
72 		entry = (struct ext4_xattr_entry *)
73 			((void *)raw_inode + EXT4_I(inode)->i_inline_off);
74 
75 		free += EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size));
76 		goto out;
77 	}
78 
79 	free -= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA));
80 
81 	if (free > EXT4_XATTR_ROUND)
82 		free = EXT4_XATTR_SIZE(free - EXT4_XATTR_ROUND);
83 	else
84 		free = 0;
85 
86 out:
87 	return free;
88 }
89 
90 /*
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.
94  */
95 int ext4_get_max_inline_size(struct inode *inode)
96 {
97 	int error, max_inline_size;
98 	struct ext4_iloc iloc;
99 
100 	if (EXT4_I(inode)->i_extra_isize == 0)
101 		return 0;
102 
103 	error = ext4_get_inode_loc(inode, &iloc);
104 	if (error) {
105 		ext4_error_inode(inode, __func__, __LINE__, 0,
106 				 "can't get inode location %lu",
107 				 inode->i_ino);
108 		return 0;
109 	}
110 
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);
114 
115 	brelse(iloc.bh);
116 
117 	if (!max_inline_size)
118 		return 0;
119 
120 	return max_inline_size + EXT4_MIN_INLINE_DATA_SIZE;
121 }
122 
123 /*
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
127  */
128 int ext4_find_inline_data_nolock(struct inode *inode)
129 {
130 	struct ext4_xattr_ibody_find is = {
131 		.s = { .not_found = -ENODATA, },
132 	};
133 	struct ext4_xattr_info i = {
134 		.name_index = EXT4_XATTR_INDEX_SYSTEM,
135 		.name = EXT4_XATTR_SYSTEM_DATA,
136 	};
137 	int error;
138 
139 	if (EXT4_I(inode)->i_extra_isize == 0)
140 		return 0;
141 
142 	error = ext4_get_inode_loc(inode, &is.iloc);
143 	if (error)
144 		return error;
145 
146 	error = ext4_xattr_ibody_find(inode, &i, &is);
147 	if (error)
148 		goto out;
149 
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);
156 	}
157 out:
158 	brelse(is.iloc.bh);
159 	return error;
160 }
161 
162 static int ext4_read_inline_data(struct inode *inode, void *buffer,
163 				 unsigned int len,
164 				 struct ext4_iloc *iloc)
165 {
166 	struct ext4_xattr_entry *entry;
167 	struct ext4_xattr_ibody_header *header;
168 	int cp_len = 0;
169 	struct ext4_inode *raw_inode;
170 
171 	if (!len)
172 		return 0;
173 
174 	BUG_ON(len > EXT4_I(inode)->i_inline_size);
175 
176 	cp_len = len < EXT4_MIN_INLINE_DATA_SIZE ?
177 			len : EXT4_MIN_INLINE_DATA_SIZE;
178 
179 	raw_inode = ext4_raw_inode(iloc);
180 	memcpy(buffer, (void *)(raw_inode->i_block), cp_len);
181 
182 	len -= cp_len;
183 	buffer += cp_len;
184 
185 	if (!len)
186 		goto out;
187 
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));
193 
194 	memcpy(buffer,
195 	       (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs), len);
196 	cp_len += len;
197 
198 out:
199 	return cp_len;
200 }
201 
202 /*
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.
207  */
208 static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc,
209 				   void *buffer, loff_t pos, unsigned int len)
210 {
211 	struct ext4_xattr_entry *entry;
212 	struct ext4_xattr_ibody_header *header;
213 	struct ext4_inode *raw_inode;
214 	int cp_len = 0;
215 
216 	BUG_ON(!EXT4_I(inode)->i_inline_off);
217 	BUG_ON(pos + len > EXT4_I(inode)->i_inline_size);
218 
219 	raw_inode = ext4_raw_inode(iloc);
220 	buffer += pos;
221 
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);
226 
227 		len -= cp_len;
228 		buffer += cp_len;
229 		pos += cp_len;
230 	}
231 
232 	if (!len)
233 		return;
234 
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);
239 
240 	memcpy((void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs) + pos,
241 	       buffer, len);
242 }
243 
244 static int ext4_create_inline_data(handle_t *handle,
245 				   struct inode *inode, unsigned len)
246 {
247 	int error;
248 	void *value = NULL;
249 	struct ext4_xattr_ibody_find is = {
250 		.s = { .not_found = -ENODATA, },
251 	};
252 	struct ext4_xattr_info i = {
253 		.name_index = EXT4_XATTR_INDEX_SYSTEM,
254 		.name = EXT4_XATTR_SYSTEM_DATA,
255 	};
256 
257 	error = ext4_get_inode_loc(inode, &is.iloc);
258 	if (error)
259 		return error;
260 
261 	BUFFER_TRACE(is.iloc.bh, "get_write_access");
262 	error = ext4_journal_get_write_access(handle, is.iloc.bh);
263 	if (error)
264 		goto out;
265 
266 	if (len > EXT4_MIN_INLINE_DATA_SIZE) {
267 		value = EXT4_ZERO_XATTR_VALUE;
268 		len -= EXT4_MIN_INLINE_DATA_SIZE;
269 	} else {
270 		value = "";
271 		len = 0;
272 	}
273 
274 	/* Insert the the xttr entry. */
275 	i.value = value;
276 	i.value_len = len;
277 
278 	error = ext4_xattr_ibody_find(inode, &i, &is);
279 	if (error)
280 		goto out;
281 
282 	BUG_ON(!is.s.not_found);
283 
284 	error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
285 	if (error) {
286 		if (error == -ENOSPC)
287 			ext4_clear_inode_state(inode,
288 					       EXT4_STATE_MAY_INLINE_DATA);
289 		goto out;
290 	}
291 
292 	memset((void *)ext4_raw_inode(&is.iloc)->i_block,
293 		0, EXT4_MIN_INLINE_DATA_SIZE);
294 
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);
300 	get_bh(is.iloc.bh);
301 	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
302 
303 out:
304 	brelse(is.iloc.bh);
305 	return error;
306 }
307 
308 static int ext4_update_inline_data(handle_t *handle, struct inode *inode,
309 				   unsigned int len)
310 {
311 	int error;
312 	void *value = NULL;
313 	struct ext4_xattr_ibody_find is = {
314 		.s = { .not_found = -ENODATA, },
315 	};
316 	struct ext4_xattr_info i = {
317 		.name_index = EXT4_XATTR_INDEX_SYSTEM,
318 		.name = EXT4_XATTR_SYSTEM_DATA,
319 	};
320 
321 	/* If the old space is ok, write the data directly. */
322 	if (len <= EXT4_I(inode)->i_inline_size)
323 		return 0;
324 
325 	error = ext4_get_inode_loc(inode, &is.iloc);
326 	if (error)
327 		return error;
328 
329 	error = ext4_xattr_ibody_find(inode, &i, &is);
330 	if (error)
331 		goto out;
332 
333 	BUG_ON(is.s.not_found);
334 
335 	len -= EXT4_MIN_INLINE_DATA_SIZE;
336 	value = kzalloc(len, GFP_NOFS);
337 	if (!value)
338 		goto out;
339 
340 	error = ext4_xattr_ibody_get(inode, i.name_index, i.name,
341 				     value, len);
342 	if (error == -ENODATA)
343 		goto out;
344 
345 	BUFFER_TRACE(is.iloc.bh, "get_write_access");
346 	error = ext4_journal_get_write_access(handle, is.iloc.bh);
347 	if (error)
348 		goto out;
349 
350 	/* Update the xttr entry. */
351 	i.value = value;
352 	i.value_len = len;
353 
354 	error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
355 	if (error)
356 		goto out;
357 
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);
363 	get_bh(is.iloc.bh);
364 	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
365 
366 out:
367 	kfree(value);
368 	brelse(is.iloc.bh);
369 	return error;
370 }
371 
372 static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,
373 				    unsigned int len)
374 {
375 	int ret, size;
376 	struct ext4_inode_info *ei = EXT4_I(inode);
377 
378 	if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA))
379 		return -ENOSPC;
380 
381 	size = ext4_get_max_inline_size(inode);
382 	if (size < len)
383 		return -ENOSPC;
384 
385 	down_write(&EXT4_I(inode)->xattr_sem);
386 
387 	if (ei->i_inline_off)
388 		ret = ext4_update_inline_data(handle, inode, len);
389 	else
390 		ret = ext4_create_inline_data(handle, inode, len);
391 
392 	up_write(&EXT4_I(inode)->xattr_sem);
393 
394 	return ret;
395 }
396 
397 static int ext4_destroy_inline_data_nolock(handle_t *handle,
398 					   struct inode *inode)
399 {
400 	struct ext4_inode_info *ei = EXT4_I(inode);
401 	struct ext4_xattr_ibody_find is = {
402 		.s = { .not_found = 0, },
403 	};
404 	struct ext4_xattr_info i = {
405 		.name_index = EXT4_XATTR_INDEX_SYSTEM,
406 		.name = EXT4_XATTR_SYSTEM_DATA,
407 		.value = NULL,
408 		.value_len = 0,
409 	};
410 	int error;
411 
412 	if (!ei->i_inline_off)
413 		return 0;
414 
415 	error = ext4_get_inode_loc(inode, &is.iloc);
416 	if (error)
417 		return error;
418 
419 	error = ext4_xattr_ibody_find(inode, &i, &is);
420 	if (error)
421 		goto out;
422 
423 	BUFFER_TRACE(is.iloc.bh, "get_write_access");
424 	error = ext4_journal_get_write_access(handle, is.iloc.bh);
425 	if (error)
426 		goto out;
427 
428 	error = ext4_xattr_ibody_inline_set(handle, inode, &i, &is);
429 	if (error)
430 		goto out;
431 
432 	memset((void *)ext4_raw_inode(&is.iloc)->i_block,
433 		0, EXT4_MIN_INLINE_DATA_SIZE);
434 
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);
441 		}
442 	}
443 	ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA);
444 
445 	get_bh(is.iloc.bh);
446 	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
447 
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);
451 out:
452 	brelse(is.iloc.bh);
453 	if (error == -ENODATA)
454 		error = 0;
455 	return error;
456 }
457 
458 static int ext4_read_inline_page(struct inode *inode, struct page *page)
459 {
460 	void *kaddr;
461 	int ret = 0;
462 	size_t len;
463 	struct ext4_iloc iloc;
464 
465 	BUG_ON(!PageLocked(page));
466 	BUG_ON(!ext4_has_inline_data(inode));
467 	BUG_ON(page->index);
468 
469 	if (!EXT4_I(inode)->i_inline_off) {
470 		ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
471 			     inode->i_ino);
472 		goto out;
473 	}
474 
475 	ret = ext4_get_inode_loc(inode, &iloc);
476 	if (ret)
477 		goto out;
478 
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);
486 	brelse(iloc.bh);
487 
488 out:
489 	return ret;
490 }
491 
492 int ext4_readpage_inline(struct inode *inode, struct page *page)
493 {
494 	int ret = 0;
495 
496 	down_read(&EXT4_I(inode)->xattr_sem);
497 	if (!ext4_has_inline_data(inode)) {
498 		up_read(&EXT4_I(inode)->xattr_sem);
499 		return -EAGAIN;
500 	}
501 
502 	/*
503 	 * Current inline data can only exist in the 1st page,
504 	 * So for all the other pages, just set them uptodate.
505 	 */
506 	if (!page->index)
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);
511 	}
512 
513 	up_read(&EXT4_I(inode)->xattr_sem);
514 
515 	unlock_page(page);
516 	return ret >= 0 ? 0 : ret;
517 }
518 
519 static int ext4_convert_inline_data_to_extent(struct address_space *mapping,
520 					      struct inode *inode,
521 					      unsigned flags)
522 {
523 	int ret, needed_blocks;
524 	handle_t *handle = NULL;
525 	int retries = 0, sem_held = 0;
526 	struct page *page = NULL;
527 	unsigned from, to;
528 	struct ext4_iloc iloc;
529 
530 	if (!ext4_has_inline_data(inode)) {
531 		/*
532 		 * clear the flag so that no new write
533 		 * will trap here again.
534 		 */
535 		ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
536 		return 0;
537 	}
538 
539 	needed_blocks = ext4_writepage_trans_blocks(inode);
540 
541 	ret = ext4_get_inode_loc(inode, &iloc);
542 	if (ret)
543 		return ret;
544 
545 retry:
546 	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
547 	if (IS_ERR(handle)) {
548 		ret = PTR_ERR(handle);
549 		handle = NULL;
550 		goto out;
551 	}
552 
553 	/* We cannot recurse into the filesystem as the transaction is already
554 	 * started */
555 	flags |= AOP_FLAG_NOFS;
556 
557 	page = grab_cache_page_write_begin(mapping, 0, flags);
558 	if (!page) {
559 		ret = -ENOMEM;
560 		goto out;
561 	}
562 
563 	down_write(&EXT4_I(inode)->xattr_sem);
564 	sem_held = 1;
565 	/* If some one has already done this for us, just exit. */
566 	if (!ext4_has_inline_data(inode)) {
567 		ret = 0;
568 		goto out;
569 	}
570 
571 	from = 0;
572 	to = ext4_get_inline_size(inode);
573 	if (!PageUptodate(page)) {
574 		ret = ext4_read_inline_page(inode, page);
575 		if (ret < 0)
576 			goto out;
577 	}
578 
579 	ret = ext4_destroy_inline_data_nolock(handle, inode);
580 	if (ret)
581 		goto out;
582 
583 	if (ext4_should_dioread_nolock(inode))
584 		ret = __block_write_begin(page, from, to, ext4_get_block_write);
585 	else
586 		ret = __block_write_begin(page, from, to, ext4_get_block);
587 
588 	if (!ret && ext4_should_journal_data(inode)) {
589 		ret = ext4_walk_page_buffers(handle, page_buffers(page),
590 					     from, to, NULL,
591 					     do_journal_get_write_access);
592 	}
593 
594 	if (ret) {
595 		unlock_page(page);
596 		page_cache_release(page);
597 		ext4_orphan_add(handle, inode);
598 		up_write(&EXT4_I(inode)->xattr_sem);
599 		sem_held = 0;
600 		ext4_journal_stop(handle);
601 		handle = NULL;
602 		ext4_truncate_failed_write(inode);
603 		/*
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.
608 		 */
609 		if (inode->i_nlink)
610 			ext4_orphan_del(NULL, inode);
611 	}
612 
613 	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
614 		goto retry;
615 
616 	block_commit_write(page, from, to);
617 out:
618 	if (page) {
619 		unlock_page(page);
620 		page_cache_release(page);
621 	}
622 	if (sem_held)
623 		up_write(&EXT4_I(inode)->xattr_sem);
624 	if (handle)
625 		ext4_journal_stop(handle);
626 	brelse(iloc.bh);
627 	return ret;
628 }
629 
630 /*
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.
635  */
636 int ext4_try_to_write_inline_data(struct address_space *mapping,
637 				  struct inode *inode,
638 				  loff_t pos, unsigned len,
639 				  unsigned flags,
640 				  struct page **pagep)
641 {
642 	int ret;
643 	handle_t *handle;
644 	struct page *page;
645 	struct ext4_iloc iloc;
646 
647 	if (pos + len > ext4_get_max_inline_size(inode))
648 		goto convert;
649 
650 	ret = ext4_get_inode_loc(inode, &iloc);
651 	if (ret)
652 		return ret;
653 
654 	/*
655 	 * The possible write could happen in the inode,
656 	 * so try to reserve the space in inode first.
657 	 */
658 	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
659 	if (IS_ERR(handle)) {
660 		ret = PTR_ERR(handle);
661 		handle = NULL;
662 		goto out;
663 	}
664 
665 	ret = ext4_prepare_inline_data(handle, inode, pos + len);
666 	if (ret && ret != -ENOSPC)
667 		goto out;
668 
669 	/* We don't have space in inline inode, so convert it to extent. */
670 	if (ret == -ENOSPC) {
671 		ext4_journal_stop(handle);
672 		brelse(iloc.bh);
673 		goto convert;
674 	}
675 
676 	flags |= AOP_FLAG_NOFS;
677 
678 	page = grab_cache_page_write_begin(mapping, 0, flags);
679 	if (!page) {
680 		ret = -ENOMEM;
681 		goto out;
682 	}
683 
684 	*pagep = page;
685 	down_read(&EXT4_I(inode)->xattr_sem);
686 	if (!ext4_has_inline_data(inode)) {
687 		ret = 0;
688 		unlock_page(page);
689 		page_cache_release(page);
690 		goto out_up_read;
691 	}
692 
693 	if (!PageUptodate(page)) {
694 		ret = ext4_read_inline_page(inode, page);
695 		if (ret < 0)
696 			goto out_up_read;
697 	}
698 
699 	ret = 1;
700 	handle = NULL;
701 out_up_read:
702 	up_read(&EXT4_I(inode)->xattr_sem);
703 out:
704 	if (handle)
705 		ext4_journal_stop(handle);
706 	brelse(iloc.bh);
707 	return ret;
708 convert:
709 	return ext4_convert_inline_data_to_extent(mapping,
710 						  inode, flags);
711 }
712 
713 int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len,
714 			       unsigned copied, struct page *page)
715 {
716 	int ret;
717 	void *kaddr;
718 	struct ext4_iloc iloc;
719 
720 	if (unlikely(copied < len)) {
721 		if (!PageUptodate(page)) {
722 			copied = 0;
723 			goto out;
724 		}
725 	}
726 
727 	ret = ext4_get_inode_loc(inode, &iloc);
728 	if (ret) {
729 		ext4_std_error(inode->i_sb, ret);
730 		copied = 0;
731 		goto out;
732 	}
733 
734 	down_write(&EXT4_I(inode)->xattr_sem);
735 	BUG_ON(!ext4_has_inline_data(inode));
736 
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);
743 
744 	up_write(&EXT4_I(inode)->xattr_sem);
745 	brelse(iloc.bh);
746 out:
747 	return copied;
748 }
749 
750 struct buffer_head *
751 ext4_journalled_write_inline_data(struct inode *inode,
752 				  unsigned len,
753 				  struct page *page)
754 {
755 	int ret;
756 	void *kaddr;
757 	struct ext4_iloc iloc;
758 
759 	ret = ext4_get_inode_loc(inode, &iloc);
760 	if (ret) {
761 		ext4_std_error(inode->i_sb, ret);
762 		return NULL;
763 	}
764 
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);
770 
771 	return iloc.bh;
772 }
773 
774 /*
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.
782  */
783 static int ext4_da_convert_inline_data_to_extent(struct address_space *mapping,
784 						 struct inode *inode,
785 						 unsigned flags,
786 						 void **fsdata)
787 {
788 	int ret = 0, inline_size;
789 	struct page *page;
790 
791 	page = grab_cache_page_write_begin(mapping, 0, flags);
792 	if (!page)
793 		return -ENOMEM;
794 
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);
798 		goto out;
799 	}
800 
801 	inline_size = ext4_get_inline_size(inode);
802 
803 	if (!PageUptodate(page)) {
804 		ret = ext4_read_inline_page(inode, page);
805 		if (ret < 0)
806 			goto out;
807 	}
808 
809 	ret = __block_write_begin(page, 0, inline_size,
810 				  ext4_da_get_block_prep);
811 	if (ret) {
812 		ext4_truncate_failed_write(inode);
813 		goto out;
814 	}
815 
816 	SetPageDirty(page);
817 	SetPageUptodate(page);
818 	ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
819 	*fsdata = (void *)CONVERT_INLINE_DATA;
820 
821 out:
822 	up_read(&EXT4_I(inode)->xattr_sem);
823 	if (page) {
824 		unlock_page(page);
825 		page_cache_release(page);
826 	}
827 	return ret;
828 }
829 
830 /*
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).
837  */
838 int ext4_da_write_inline_data_begin(struct address_space *mapping,
839 				    struct inode *inode,
840 				    loff_t pos, unsigned len,
841 				    unsigned flags,
842 				    struct page **pagep,
843 				    void **fsdata)
844 {
845 	int ret, inline_size;
846 	handle_t *handle;
847 	struct page *page;
848 	struct ext4_iloc iloc;
849 	int retries;
850 
851 	ret = ext4_get_inode_loc(inode, &iloc);
852 	if (ret)
853 		return ret;
854 
855 retry_journal:
856 	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
857 	if (IS_ERR(handle)) {
858 		ret = PTR_ERR(handle);
859 		goto out;
860 	}
861 
862 	inline_size = ext4_get_max_inline_size(inode);
863 
864 	ret = -ENOSPC;
865 	if (inline_size >= pos + len) {
866 		ret = ext4_prepare_inline_data(handle, inode, pos + len);
867 		if (ret && ret != -ENOSPC)
868 			goto out_journal;
869 	}
870 
871 	if (ret == -ENOSPC) {
872 		ret = ext4_da_convert_inline_data_to_extent(mapping,
873 							    inode,
874 							    flags,
875 							    fsdata);
876 		ext4_journal_stop(handle);
877 		if (ret == -ENOSPC &&
878 		    ext4_should_retry_alloc(inode->i_sb, &retries))
879 			goto retry_journal;
880 		goto out;
881 	}
882 
883 	/*
884 	 * We cannot recurse into the filesystem as the transaction
885 	 * is already started.
886 	 */
887 	flags |= AOP_FLAG_NOFS;
888 
889 	page = grab_cache_page_write_begin(mapping, 0, flags);
890 	if (!page) {
891 		ret = -ENOMEM;
892 		goto out_journal;
893 	}
894 
895 	down_read(&EXT4_I(inode)->xattr_sem);
896 	if (!ext4_has_inline_data(inode)) {
897 		ret = 0;
898 		goto out_release_page;
899 	}
900 
901 	if (!PageUptodate(page)) {
902 		ret = ext4_read_inline_page(inode, page);
903 		if (ret < 0)
904 			goto out_release_page;
905 	}
906 
907 	up_read(&EXT4_I(inode)->xattr_sem);
908 	*pagep = page;
909 	brelse(iloc.bh);
910 	return 1;
911 out_release_page:
912 	up_read(&EXT4_I(inode)->xattr_sem);
913 	unlock_page(page);
914 	page_cache_release(page);
915 out_journal:
916 	ext4_journal_stop(handle);
917 out:
918 	brelse(iloc.bh);
919 	return ret;
920 }
921 
922 int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
923 				  unsigned len, unsigned copied,
924 				  struct page *page)
925 {
926 	int i_size_changed = 0;
927 
928 	copied = ext4_write_inline_data_end(inode, pos, len, copied, page);
929 
930 	/*
931 	 * No need to use i_size_read() here, the i_size
932 	 * cannot change under us because we hold i_mutex.
933 	 *
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.
936 	 */
937 	if (pos+copied > inode->i_size) {
938 		i_size_write(inode, pos+copied);
939 		i_size_changed = 1;
940 	}
941 	unlock_page(page);
942 	page_cache_release(page);
943 
944 	/*
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
948 	 * filesystems.
949 	 */
950 	if (i_size_changed)
951 		mark_inode_dirty(inode);
952 
953 	return copied;
954 }
955 
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)
959 {
960 	int offset;
961 	unsigned short de_len;
962 	struct ext4_dir_entry_2 *de = inline_start;
963 	void *dlimit = inline_start + inline_size;
964 
965 	trace_printk("inode %lu\n", dir->i_ino);
966 	offset = 0;
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))
974 			BUG();
975 
976 		offset += de_len;
977 		de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
978 	}
979 }
980 #else
981 #define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
982 #endif
983 
984 /*
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.
988  */
989 static int ext4_add_dirent_to_inline(handle_t *handle,
990 				     struct dentry *dentry,
991 				     struct inode *inode,
992 				     struct ext4_iloc *iloc,
993 				     void *inline_start, int inline_size)
994 {
995 	struct inode	*dir = dentry->d_parent->d_inode;
996 	const char	*name = dentry->d_name.name;
997 	int		namelen = dentry->d_name.len;
998 	int		err;
999 	struct ext4_dir_entry_2 *de;
1000 
1001 	err = ext4_find_dest_de(dir, inode, iloc->bh,
1002 				inline_start, inline_size,
1003 				name, namelen, &de);
1004 	if (err)
1005 		return err;
1006 
1007 	BUFFER_TRACE(iloc->bh, "get_write_access");
1008 	err = ext4_journal_get_write_access(handle, iloc->bh);
1009 	if (err)
1010 		return err;
1011 	ext4_insert_dentry(inode, de, inline_size, name, namelen);
1012 
1013 	ext4_show_inline_dir(dir, iloc->bh, inline_start, inline_size);
1014 
1015 	/*
1016 	 * XXX shouldn't update any times until successful
1017 	 * completion of syscall, but too many callers depend
1018 	 * on this.
1019 	 *
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.
1025 	 */
1026 	dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
1027 	ext4_update_dx_flag(dir);
1028 	dir->i_version++;
1029 	ext4_mark_inode_dirty(handle, dir);
1030 	return 1;
1031 }
1032 
1033 static void *ext4_get_inline_xattr_pos(struct inode *inode,
1034 				       struct ext4_iloc *iloc)
1035 {
1036 	struct ext4_xattr_entry *entry;
1037 	struct ext4_xattr_ibody_header *header;
1038 
1039 	BUG_ON(!EXT4_I(inode)->i_inline_off);
1040 
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);
1044 
1045 	return (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs);
1046 }
1047 
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)
1050 {
1051 	struct ext4_dir_entry_2 *de, *prev_de;
1052 	void *limit;
1053 	int de_len;
1054 
1055 	de = (struct ext4_dir_entry_2 *)de_buf;
1056 	if (old_size) {
1057 		limit = de_buf + old_size;
1058 		do {
1059 			prev_de = de;
1060 			de_len = ext4_rec_len_from_disk(de->rec_len, old_size);
1061 			de_buf += de_len;
1062 			de = (struct ext4_dir_entry_2 *)de_buf;
1063 		} while (de_buf < limit);
1064 
1065 		prev_de->rec_len = ext4_rec_len_to_disk(de_len + new_size -
1066 							old_size, new_size);
1067 	} else {
1068 		/* this is just created, so create an empty entry. */
1069 		de->inode = 0;
1070 		de->rec_len = ext4_rec_len_to_disk(new_size, new_size);
1071 	}
1072 }
1073 
1074 static int ext4_update_inline_dir(handle_t *handle, struct inode *dir,
1075 				  struct ext4_iloc *iloc)
1076 {
1077 	int ret;
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);
1080 
1081 	if (new_size - old_size <= EXT4_DIR_REC_LEN(1))
1082 		return -ENOSPC;
1083 
1084 	ret = ext4_update_inline_data(handle, dir,
1085 				      new_size + EXT4_MIN_INLINE_DATA_SIZE);
1086 	if (ret)
1087 		return ret;
1088 
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;
1093 	return 0;
1094 }
1095 
1096 static void ext4_restore_inline_data(handle_t *handle, struct inode *inode,
1097 				     struct ext4_iloc *iloc,
1098 				     void *buf, int inline_size)
1099 {
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);
1103 }
1104 
1105 static int ext4_finish_convert_inline_dir(handle_t *handle,
1106 					  struct inode *inode,
1107 					  struct buffer_head *dir_block,
1108 					  void *buf,
1109 					  int inline_size)
1110 {
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;
1115 
1116 	/*
1117 	 * First create "." and ".." and then copy the dir information
1118 	 * back to the block.
1119 	 */
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;
1125 
1126 	memcpy((void *)de, buf + EXT4_INLINE_DOTDOT_SIZE,
1127 		inline_size - EXT4_INLINE_DOTDOT_SIZE);
1128 
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);
1132 
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);
1139 
1140 	if (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);
1144 	}
1145 	set_buffer_uptodate(dir_block);
1146 	err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
1147 	if (err)
1148 		goto out;
1149 	set_buffer_verified(dir_block);
1150 out:
1151 	return err;
1152 }
1153 
1154 static int ext4_convert_inline_data_nolock(handle_t *handle,
1155 					   struct inode *inode,
1156 					   struct ext4_iloc *iloc)
1157 {
1158 	int error;
1159 	void *buf = NULL;
1160 	struct buffer_head *data_bh = NULL;
1161 	struct ext4_map_blocks map;
1162 	int inline_size;
1163 
1164 	inline_size = ext4_get_inline_size(inode);
1165 	buf = kmalloc(inline_size, GFP_NOFS);
1166 	if (!buf) {
1167 		error = -ENOMEM;
1168 		goto out;
1169 	}
1170 
1171 	error = ext4_read_inline_data(inode, buf, inline_size, iloc);
1172 	if (error < 0)
1173 		goto out;
1174 
1175 	/*
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.
1178 	 */
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);
1183 		if (error)
1184 			goto out;
1185 	}
1186 
1187 	error = ext4_destroy_inline_data_nolock(handle, inode);
1188 	if (error)
1189 		goto out;
1190 
1191 	map.m_lblk = 0;
1192 	map.m_len = 1;
1193 	map.m_flags = 0;
1194 	error = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_CREATE);
1195 	if (error < 0)
1196 		goto out_restore;
1197 	if (!(map.m_flags & EXT4_MAP_MAPPED)) {
1198 		error = -EIO;
1199 		goto out_restore;
1200 	}
1201 
1202 	data_bh = sb_getblk(inode->i_sb, map.m_pblk);
1203 	if (!data_bh) {
1204 		error = -ENOMEM;
1205 		goto out_restore;
1206 	}
1207 
1208 	lock_buffer(data_bh);
1209 	error = ext4_journal_get_create_access(handle, data_bh);
1210 	if (error) {
1211 		unlock_buffer(data_bh);
1212 		error = -EIO;
1213 		goto out_restore;
1214 	}
1215 	memset(data_bh->b_data, 0, inode->i_sb->s_blocksize);
1216 
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,
1221 						   inode, data_bh);
1222 	} else {
1223 		error = ext4_finish_convert_inline_dir(handle, inode, data_bh,
1224 						       buf, inline_size);
1225 	}
1226 
1227 	unlock_buffer(data_bh);
1228 out_restore:
1229 	if (error)
1230 		ext4_restore_inline_data(handle, inode, iloc, buf, inline_size);
1231 
1232 out:
1233 	brelse(data_bh);
1234 	kfree(buf);
1235 	return error;
1236 }
1237 
1238 /*
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.
1242  */
1243 int ext4_try_add_inline_entry(handle_t *handle, struct dentry *dentry,
1244 			      struct inode *inode)
1245 {
1246 	int ret, inline_size;
1247 	void *inline_start;
1248 	struct ext4_iloc iloc;
1249 	struct inode *dir = dentry->d_parent->d_inode;
1250 
1251 	ret = ext4_get_inode_loc(dir, &iloc);
1252 	if (ret)
1253 		return ret;
1254 
1255 	down_write(&EXT4_I(dir)->xattr_sem);
1256 	if (!ext4_has_inline_data(dir))
1257 		goto out;
1258 
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;
1262 
1263 	ret = ext4_add_dirent_to_inline(handle, dentry, inode, &iloc,
1264 					inline_start, inline_size);
1265 	if (ret != -ENOSPC)
1266 		goto out;
1267 
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;
1271 	if (!inline_size) {
1272 		/* Try to use the xattr space.*/
1273 		ret = ext4_update_inline_dir(handle, dir, &iloc);
1274 		if (ret && ret != -ENOSPC)
1275 			goto out;
1276 
1277 		inline_size = EXT4_I(dir)->i_inline_size -
1278 				EXT4_MIN_INLINE_DATA_SIZE;
1279 	}
1280 
1281 	if (inline_size) {
1282 		inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1283 
1284 		ret = ext4_add_dirent_to_inline(handle, dentry, inode, &iloc,
1285 						inline_start, inline_size);
1286 
1287 		if (ret != -ENOSPC)
1288 			goto out;
1289 	}
1290 
1291 	/*
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
1294 	 * dir first.
1295 	 */
1296 	ret = ext4_convert_inline_data_nolock(handle, dir, &iloc);
1297 
1298 out:
1299 	ext4_mark_inode_dirty(handle, dir);
1300 	up_write(&EXT4_I(dir)->xattr_sem);
1301 	brelse(iloc.bh);
1302 	return ret;
1303 }
1304 
1305 /*
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.
1309  */
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)
1315 {
1316 	int err = 0, count = 0;
1317 	unsigned int parent_ino;
1318 	int pos;
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;
1325 
1326 	ret = ext4_get_inode_loc(inode, &iloc);
1327 	if (ret)
1328 		return ret;
1329 
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;
1334 		goto out;
1335 	}
1336 
1337 	inline_size = ext4_get_inline_size(inode);
1338 	dir_buf = kmalloc(inline_size, GFP_NOFS);
1339 	if (!dir_buf) {
1340 		ret = -ENOMEM;
1341 		up_read(&EXT4_I(inode)->xattr_sem);
1342 		goto out;
1343 	}
1344 
1345 	ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1346 	up_read(&EXT4_I(inode)->xattr_sem);
1347 	if (ret < 0)
1348 		goto out;
1349 
1350 	pos = 0;
1351 	parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1352 	while (pos < inline_size) {
1353 		/*
1354 		 * As inlined dir doesn't store any information about '.' and
1355 		 * only the inode number of '..' is stored, we have to handle
1356 		 * them differently.
1357 		 */
1358 		if (pos == 0) {
1359 			fake.inode = cpu_to_le32(inode->i_ino);
1360 			fake.name_len = 1;
1361 			strcpy(fake.name, ".");
1362 			fake.rec_len = ext4_rec_len_to_disk(
1363 						EXT4_DIR_REC_LEN(fake.name_len),
1364 						inline_size);
1365 			ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1366 			de = &fake;
1367 			pos = EXT4_INLINE_DOTDOT_OFFSET;
1368 		} else if (pos == EXT4_INLINE_DOTDOT_OFFSET) {
1369 			fake.inode = cpu_to_le32(parent_ino);
1370 			fake.name_len = 2;
1371 			strcpy(fake.name, "..");
1372 			fake.rec_len = ext4_rec_len_to_disk(
1373 						EXT4_DIR_REC_LEN(fake.name_len),
1374 						inline_size);
1375 			ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1376 			de = &fake;
1377 			pos = EXT4_INLINE_DOTDOT_SIZE;
1378 		} else {
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,
1382 					 iloc.bh, dir_buf,
1383 					 inline_size, pos)) {
1384 				ret = count;
1385 				goto out;
1386 			}
1387 		}
1388 
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)))
1393 			continue;
1394 		if (de->inode == 0)
1395 			continue;
1396 		err = ext4_htree_store_dirent(dir_file,
1397 				   hinfo->hash, hinfo->minor_hash, de);
1398 		if (err) {
1399 			count = err;
1400 			goto out;
1401 		}
1402 		count++;
1403 	}
1404 	ret = count;
1405 out:
1406 	kfree(dir_buf);
1407 	brelse(iloc.bh);
1408 	return ret;
1409 }
1410 
1411 /*
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.
1417  *
1418  */
1419 int ext4_read_inline_dir(struct file *file,
1420 			 struct dir_context *ctx,
1421 			 int *has_inline_data)
1422 {
1423 	unsigned int offset, parent_ino;
1424 	int i;
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;
1432 
1433 	ret = ext4_get_inode_loc(inode, &iloc);
1434 	if (ret)
1435 		return ret;
1436 
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;
1441 		goto out;
1442 	}
1443 
1444 	inline_size = ext4_get_inline_size(inode);
1445 	dir_buf = kmalloc(inline_size, GFP_NOFS);
1446 	if (!dir_buf) {
1447 		ret = -ENOMEM;
1448 		up_read(&EXT4_I(inode)->xattr_sem);
1449 		goto out;
1450 	}
1451 
1452 	ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1453 	up_read(&EXT4_I(inode)->xattr_sem);
1454 	if (ret < 0)
1455 		goto out;
1456 
1457 	ret = 0;
1458 	sb = inode->i_sb;
1459 	parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1460 	offset = ctx->pos;
1461 
1462 	/*
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.
1468 	 */
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;
1473 
1474 	/*
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
1478 	 * dir to make sure.
1479 	 */
1480 	if (file->f_version != inode->i_version) {
1481 		for (i = 0; i < extra_size && i < offset;) {
1482 			/*
1483 			 * "." is with offset 0 and
1484 			 * ".." is dotdot_offset.
1485 			 */
1486 			if (!i) {
1487 				i = dotdot_offset;
1488 				continue;
1489 			} else if (i == dotdot_offset) {
1490 				i = dotdot_size;
1491 				continue;
1492 			}
1493 			/* for other entry, the real offset in
1494 			 * the buf has to be tuned accordingly.
1495 			 */
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))
1506 				break;
1507 			i += ext4_rec_len_from_disk(de->rec_len,
1508 						    extra_size);
1509 		}
1510 		offset = i;
1511 		ctx->pos = offset;
1512 		file->f_version = inode->i_version;
1513 	}
1514 
1515 	while (ctx->pos < extra_size) {
1516 		if (ctx->pos == 0) {
1517 			if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR))
1518 				goto out;
1519 			ctx->pos = dotdot_offset;
1520 			continue;
1521 		}
1522 
1523 		if (ctx->pos == dotdot_offset) {
1524 			if (!dir_emit(ctx, "..", 2, parent_ino, DT_DIR))
1525 				goto out;
1526 			ctx->pos = dotdot_size;
1527 			continue;
1528 		}
1529 
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))
1534 			goto out;
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)))
1539 				goto out;
1540 		}
1541 		ctx->pos += ext4_rec_len_from_disk(de->rec_len, extra_size);
1542 	}
1543 out:
1544 	kfree(dir_buf);
1545 	brelse(iloc.bh);
1546 	return ret;
1547 }
1548 
1549 struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
1550 					struct ext4_dir_entry_2 **parent_de,
1551 					int *retval)
1552 {
1553 	struct ext4_iloc iloc;
1554 
1555 	*retval = ext4_get_inode_loc(inode, &iloc);
1556 	if (*retval)
1557 		return NULL;
1558 
1559 	*parent_de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
1560 
1561 	return iloc.bh;
1562 }
1563 
1564 /*
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.
1568  */
1569 int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent,
1570 			       struct inode *inode)
1571 {
1572 	int ret, inline_size = EXT4_MIN_INLINE_DATA_SIZE;
1573 	struct ext4_iloc iloc;
1574 	struct ext4_dir_entry_2 *de;
1575 
1576 	ret = ext4_get_inode_loc(inode, &iloc);
1577 	if (ret)
1578 		return ret;
1579 
1580 	ret = ext4_prepare_inline_data(handle, inode, inline_size);
1581 	if (ret)
1582 		goto out;
1583 
1584 	/*
1585 	 * For inline dir, we only save the inode information for the ".."
1586 	 * and create a fake dentry to cover the left space.
1587 	 */
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);
1591 	de->inode = 0;
1592 	de->rec_len = ext4_rec_len_to_disk(
1593 				inline_size - EXT4_INLINE_DOTDOT_SIZE,
1594 				inline_size);
1595 	set_nlink(inode, 2);
1596 	inode->i_size = EXT4_I(inode)->i_disksize = inline_size;
1597 out:
1598 	brelse(iloc.bh);
1599 	return ret;
1600 }
1601 
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)
1606 {
1607 	int ret;
1608 	struct ext4_iloc iloc;
1609 	void *inline_start;
1610 	int inline_size;
1611 
1612 	if (ext4_get_inode_loc(dir, &iloc))
1613 		return NULL;
1614 
1615 	down_read(&EXT4_I(dir)->xattr_sem);
1616 	if (!ext4_has_inline_data(dir)) {
1617 		*has_inline_data = 0;
1618 		goto out;
1619 	}
1620 
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);
1626 	if (ret == 1)
1627 		goto out_find;
1628 	if (ret < 0)
1629 		goto out;
1630 
1631 	if (ext4_get_inline_size(dir) == EXT4_MIN_INLINE_DATA_SIZE)
1632 		goto out;
1633 
1634 	inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1635 	inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE;
1636 
1637 	ret = search_dir(iloc.bh, inline_start, inline_size,
1638 			 dir, d_name, 0, res_dir);
1639 	if (ret == 1)
1640 		goto out_find;
1641 
1642 out:
1643 	brelse(iloc.bh);
1644 	iloc.bh = NULL;
1645 out_find:
1646 	up_read(&EXT4_I(dir)->xattr_sem);
1647 	return iloc.bh;
1648 }
1649 
1650 int ext4_delete_inline_entry(handle_t *handle,
1651 			     struct inode *dir,
1652 			     struct ext4_dir_entry_2 *de_del,
1653 			     struct buffer_head *bh,
1654 			     int *has_inline_data)
1655 {
1656 	int err, inline_size;
1657 	struct ext4_iloc iloc;
1658 	void *inline_start;
1659 
1660 	err = ext4_get_inode_loc(dir, &iloc);
1661 	if (err)
1662 		return err;
1663 
1664 	down_write(&EXT4_I(dir)->xattr_sem);
1665 	if (!ext4_has_inline_data(dir)) {
1666 		*has_inline_data = 0;
1667 		goto out;
1668 	}
1669 
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;
1676 	} else {
1677 		inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1678 		inline_size = ext4_get_inline_size(dir) -
1679 				EXT4_MIN_INLINE_DATA_SIZE;
1680 	}
1681 
1682 	BUFFER_TRACE(bh, "get_write_access");
1683 	err = ext4_journal_get_write_access(handle, bh);
1684 	if (err)
1685 		goto out;
1686 
1687 	err = ext4_generic_delete_entry(handle, dir, de_del, bh,
1688 					inline_start, inline_size, 0);
1689 	if (err)
1690 		goto out;
1691 
1692 	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1693 	err = ext4_mark_inode_dirty(handle, dir);
1694 	if (unlikely(err))
1695 		goto out;
1696 
1697 	ext4_show_inline_dir(dir, iloc.bh, inline_start, inline_size);
1698 out:
1699 	up_write(&EXT4_I(dir)->xattr_sem);
1700 	brelse(iloc.bh);
1701 	if (err != -ENOENT)
1702 		ext4_std_error(dir->i_sb, err);
1703 	return err;
1704 }
1705 
1706 /*
1707  * Get the inline dentry at offset.
1708  */
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,
1714 		      int *inline_size)
1715 {
1716 	void *inline_pos;
1717 
1718 	BUG_ON(offset > ext4_get_inline_size(inode));
1719 
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;
1723 	} else {
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;
1728 	}
1729 
1730 	if (inline_start)
1731 		*inline_start = inline_pos;
1732 	return (struct ext4_dir_entry_2 *)(inline_pos + offset);
1733 }
1734 
1735 int empty_inline_dir(struct inode *dir, int *has_inline_data)
1736 {
1737 	int err, inline_size;
1738 	struct ext4_iloc iloc;
1739 	void *inline_pos;
1740 	unsigned int offset;
1741 	struct ext4_dir_entry_2 *de;
1742 	int ret = 1;
1743 
1744 	err = ext4_get_inode_loc(dir, &iloc);
1745 	if (err) {
1746 		EXT4_ERROR_INODE(dir, "error %d getting inode %lu block",
1747 				 err, dir->i_ino);
1748 		return 1;
1749 	}
1750 
1751 	down_read(&EXT4_I(dir)->xattr_sem);
1752 	if (!ext4_has_inline_data(dir)) {
1753 		*has_inline_data = 0;
1754 		goto out;
1755 	}
1756 
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 `..'",
1761 			     dir->i_ino);
1762 		ret = 1;
1763 		goto out;
1764 	}
1765 
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"
1776 				     "inline size %d\n",
1777 				     dir->i_ino, le32_to_cpu(de->inode),
1778 				     le16_to_cpu(de->rec_len), de->name_len,
1779 				     inline_size);
1780 			ret = 1;
1781 			goto out;
1782 		}
1783 		if (le32_to_cpu(de->inode)) {
1784 			ret = 0;
1785 			goto out;
1786 		}
1787 		offset += ext4_rec_len_from_disk(de->rec_len, inline_size);
1788 	}
1789 
1790 out:
1791 	up_read(&EXT4_I(dir)->xattr_sem);
1792 	brelse(iloc.bh);
1793 	return ret;
1794 }
1795 
1796 int ext4_destroy_inline_data(handle_t *handle, struct inode *inode)
1797 {
1798 	int ret;
1799 
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);
1803 
1804 	return ret;
1805 }
1806 
1807 int ext4_inline_data_fiemap(struct inode *inode,
1808 			    struct fiemap_extent_info *fieinfo,
1809 			    int *has_inline)
1810 {
1811 	__u64 physical = 0;
1812 	__u64 length;
1813 	__u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_LAST;
1814 	int error = 0;
1815 	struct ext4_iloc iloc;
1816 
1817 	down_read(&EXT4_I(inode)->xattr_sem);
1818 	if (!ext4_has_inline_data(inode)) {
1819 		*has_inline = 0;
1820 		goto out;
1821 	}
1822 
1823 	error = ext4_get_inode_loc(inode, &iloc);
1824 	if (error)
1825 		goto out;
1826 
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);
1831 
1832 	if (physical)
1833 		error = fiemap_fill_next_extent(fieinfo, 0, physical,
1834 						length, flags);
1835 	brelse(iloc.bh);
1836 out:
1837 	up_read(&EXT4_I(inode)->xattr_sem);
1838 	return (error < 0 ? error : 0);
1839 }
1840 
1841 /*
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.
1844  *
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.
1848  */
1849 int ext4_try_to_evict_inline_data(handle_t *handle,
1850 				  struct inode *inode,
1851 				  int needed)
1852 {
1853 	int error;
1854 	struct ext4_xattr_entry *entry;
1855 	struct ext4_inode *raw_inode;
1856 	struct ext4_iloc iloc;
1857 
1858 	error = ext4_get_inode_loc(inode, &iloc);
1859 	if (error)
1860 		return error;
1861 
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) {
1867 		error = -ENOSPC;
1868 		goto out;
1869 	}
1870 
1871 	error = ext4_convert_inline_data_nolock(handle, inode, &iloc);
1872 out:
1873 	brelse(iloc.bh);
1874 	return error;
1875 }
1876 
1877 void ext4_inline_data_truncate(struct inode *inode, int *has_inline)
1878 {
1879 	handle_t *handle;
1880 	int inline_size, value_len, needed_blocks;
1881 	size_t i_size;
1882 	void *value = NULL;
1883 	struct ext4_xattr_ibody_find is = {
1884 		.s = { .not_found = -ENODATA, },
1885 	};
1886 	struct ext4_xattr_info i = {
1887 		.name_index = EXT4_XATTR_INDEX_SYSTEM,
1888 		.name = EXT4_XATTR_SYSTEM_DATA,
1889 	};
1890 
1891 
1892 	needed_blocks = ext4_writepage_trans_blocks(inode);
1893 	handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
1894 	if (IS_ERR(handle))
1895 		return;
1896 
1897 	down_write(&EXT4_I(inode)->xattr_sem);
1898 	if (!ext4_has_inline_data(inode)) {
1899 		*has_inline = 0;
1900 		ext4_journal_stop(handle);
1901 		return;
1902 	}
1903 
1904 	if (ext4_orphan_add(handle, inode))
1905 		goto out;
1906 
1907 	if (ext4_get_inode_loc(inode, &is.iloc))
1908 		goto out;
1909 
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;
1914 
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))
1919 				goto out_error;
1920 
1921 			BUG_ON(is.s.not_found);
1922 
1923 			value_len = le32_to_cpu(is.s.here->e_value_size);
1924 			value = kmalloc(value_len, GFP_NOFS);
1925 			if (!value)
1926 				goto out_error;
1927 
1928 			if (ext4_xattr_ibody_get(inode, i.name_index, i.name,
1929 						value, value_len))
1930 				goto out_error;
1931 
1932 			i.value = value;
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))
1936 				goto out_error;
1937 		}
1938 
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);
1944 		}
1945 
1946 		EXT4_I(inode)->i_inline_size = i_size <
1947 					EXT4_MIN_INLINE_DATA_SIZE ?
1948 					EXT4_MIN_INLINE_DATA_SIZE : i_size;
1949 	}
1950 
1951 out_error:
1952 	up_write(&EXT4_I(inode)->i_data_sem);
1953 out:
1954 	brelse(is.iloc.bh);
1955 	up_write(&EXT4_I(inode)->xattr_sem);
1956 	kfree(value);
1957 	if (inode->i_nlink)
1958 		ext4_orphan_del(handle, inode);
1959 
1960 	inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
1961 	ext4_mark_inode_dirty(handle, inode);
1962 	if (IS_SYNC(inode))
1963 		ext4_handle_sync(handle);
1964 
1965 	ext4_journal_stop(handle);
1966 	return;
1967 }
1968 
1969 int ext4_convert_inline_data(struct inode *inode)
1970 {
1971 	int error, needed_blocks;
1972 	handle_t *handle;
1973 	struct ext4_iloc iloc;
1974 
1975 	if (!ext4_has_inline_data(inode)) {
1976 		ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1977 		return 0;
1978 	}
1979 
1980 	needed_blocks = ext4_writepage_trans_blocks(inode);
1981 
1982 	iloc.bh = NULL;
1983 	error = ext4_get_inode_loc(inode, &iloc);
1984 	if (error)
1985 		return error;
1986 
1987 	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1988 	if (IS_ERR(handle)) {
1989 		error = PTR_ERR(handle);
1990 		goto out_free;
1991 	}
1992 
1993 	down_write(&EXT4_I(inode)->xattr_sem);
1994 	if (!ext4_has_inline_data(inode)) {
1995 		up_write(&EXT4_I(inode)->xattr_sem);
1996 		goto out;
1997 	}
1998 
1999 	error = ext4_convert_inline_data_nolock(handle, inode, &iloc);
2000 	up_write(&EXT4_I(inode)->xattr_sem);
2001 out:
2002 	ext4_journal_stop(handle);
2003 out_free:
2004 	brelse(iloc.bh);
2005 	return error;
2006 }
2007