1// SPDX-License-Identifier: LGPL-2.1
   2/*
   3 * Copyright (c) 2012 Taobao.
   4 * Written by Tao Ma <boyu.mt@taobao.com>
   5 */
   6
   7#include <linux/iomap.h>
   8#include <linux/fiemap.h>
   9#include <linux/iversion.h>
  10
  11#include "ext4_jbd2.h"
  12#include "ext4.h"
  13#include "xattr.h"
  14#include "truncate.h"
  15
  16#define EXT4_XATTR_SYSTEM_DATA	"data"
  17#define EXT4_MIN_INLINE_DATA_SIZE	((sizeof(__le32) * EXT4_N_BLOCKS))
  18#define EXT4_INLINE_DOTDOT_OFFSET	2
  19#define EXT4_INLINE_DOTDOT_SIZE		4
  20
  21static int ext4_get_inline_size(struct inode *inode)
  22{
  23	if (EXT4_I(inode)->i_inline_off)
  24		return EXT4_I(inode)->i_inline_size;
  25
  26	return 0;
  27}
  28
  29static int get_max_inline_xattr_value_size(struct inode *inode,
  30					   struct ext4_iloc *iloc)
  31{
  32	struct ext4_xattr_ibody_header *header;
  33	struct ext4_xattr_entry *entry;
  34	struct ext4_inode *raw_inode;
  35	int free, min_offs;
  36
  37	min_offs = EXT4_SB(inode->i_sb)->s_inode_size -
  38			EXT4_GOOD_OLD_INODE_SIZE -
  39			EXT4_I(inode)->i_extra_isize -
  40			sizeof(struct ext4_xattr_ibody_header);
  41
  42	/*
  43	 * We need to subtract another sizeof(__u32) since an in-inode xattr
  44	 * needs an empty 4 bytes to indicate the gap between the xattr entry
  45	 * and the name/value pair.
  46	 */
  47	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
  48		return EXT4_XATTR_SIZE(min_offs -
  49			EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA)) -
  50			EXT4_XATTR_ROUND - sizeof(__u32));
  51
  52	raw_inode = ext4_raw_inode(iloc);
  53	header = IHDR(inode, raw_inode);
  54	entry = IFIRST(header);
  55
  56	/* Compute min_offs. */
  57	for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
  58		if (!entry->e_value_inum && entry->e_value_size) {
  59			size_t offs = le16_to_cpu(entry->e_value_offs);
  60			if (offs < min_offs)
  61				min_offs = offs;
  62		}
  63	}
  64	free = min_offs -
  65		((void *)entry - (void *)IFIRST(header)) - sizeof(__u32);
  66
  67	if (EXT4_I(inode)->i_inline_off) {
  68		entry = (struct ext4_xattr_entry *)
  69			((void *)raw_inode + EXT4_I(inode)->i_inline_off);
  70
  71		free += EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size));
  72		goto out;
  73	}
  74
  75	free -= EXT4_XATTR_LEN(strlen(EXT4_XATTR_SYSTEM_DATA));
  76
  77	if (free > EXT4_XATTR_ROUND)
  78		free = EXT4_XATTR_SIZE(free - EXT4_XATTR_ROUND);
  79	else
  80		free = 0;
  81
  82out:
  83	return free;
  84}
  85
  86/*
  87 * Get the maximum size we now can store in an inode.
  88 * If we can't find the space for a xattr entry, don't use the space
  89 * of the extents since we have no space to indicate the inline data.
  90 */
  91int ext4_get_max_inline_size(struct inode *inode)
  92{
  93	int error, max_inline_size;
  94	struct ext4_iloc iloc;
  95
  96	if (EXT4_I(inode)->i_extra_isize == 0)
  97		return 0;
  98
  99	error = ext4_get_inode_loc(inode, &iloc);
 100	if (error) {
 101		ext4_error_inode_err(inode, __func__, __LINE__, 0, -error,
 102				     "can't get inode location %lu",
 103				     inode->i_ino);
 104		return 0;
 105	}
 106
 107	down_read(&EXT4_I(inode)->xattr_sem);
 108	max_inline_size = get_max_inline_xattr_value_size(inode, &iloc);
 109	up_read(&EXT4_I(inode)->xattr_sem);
 110
 111	brelse(iloc.bh);
 112
 113	if (!max_inline_size)
 114		return 0;
 115
 116	return max_inline_size + EXT4_MIN_INLINE_DATA_SIZE;
 117}
 118
 119/*
 120 * this function does not take xattr_sem, which is OK because it is
 121 * currently only used in a code path coming form ext4_iget, before
 122 * the new inode has been unlocked
 123 */
 124int ext4_find_inline_data_nolock(struct inode *inode)
 125{
 126	struct ext4_xattr_ibody_find is = {
 127		.s = { .not_found = -ENODATA, },
 128	};
 129	struct ext4_xattr_info i = {
 130		.name_index = EXT4_XATTR_INDEX_SYSTEM,
 131		.name = EXT4_XATTR_SYSTEM_DATA,
 132	};
 133	int error;
 134
 135	if (EXT4_I(inode)->i_extra_isize == 0)
 136		return 0;
 137
 138	error = ext4_get_inode_loc(inode, &is.iloc);
 139	if (error)
 140		return error;
 141
 142	error = ext4_xattr_ibody_find(inode, &i, &is);
 143	if (error)
 144		goto out;
 145
 146	if (!is.s.not_found) {
 147		if (is.s.here->e_value_inum) {
 148			EXT4_ERROR_INODE(inode, "inline data xattr refers "
 149					 "to an external xattr inode");
 150			error = -EFSCORRUPTED;
 151			goto out;
 152		}
 153		EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
 154					(void *)ext4_raw_inode(&is.iloc));
 155		EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
 156				le32_to_cpu(is.s.here->e_value_size);
 157		ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 158	}
 159out:
 160	brelse(is.iloc.bh);
 161	return error;
 162}
 163
 164static int ext4_read_inline_data(struct inode *inode, void *buffer,
 165				 unsigned int len,
 166				 struct ext4_iloc *iloc)
 167{
 168	struct ext4_xattr_entry *entry;
 169	struct ext4_xattr_ibody_header *header;
 170	int cp_len = 0;
 171	struct ext4_inode *raw_inode;
 172
 173	if (!len)
 174		return 0;
 175
 176	BUG_ON(len > EXT4_I(inode)->i_inline_size);
 177
 178	cp_len = len < EXT4_MIN_INLINE_DATA_SIZE ?
 179			len : EXT4_MIN_INLINE_DATA_SIZE;
 180
 181	raw_inode = ext4_raw_inode(iloc);
 182	memcpy(buffer, (void *)(raw_inode->i_block), cp_len);
 183
 184	len -= cp_len;
 185	buffer += cp_len;
 186
 187	if (!len)
 188		goto out;
 189
 190	header = IHDR(inode, raw_inode);
 191	entry = (struct ext4_xattr_entry *)((void *)raw_inode +
 192					    EXT4_I(inode)->i_inline_off);
 193	len = min_t(unsigned int, len,
 194		    (unsigned int)le32_to_cpu(entry->e_value_size));
 195
 196	memcpy(buffer,
 197	       (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs), len);
 198	cp_len += len;
 199
 200out:
 201	return cp_len;
 202}
 203
 204/*
 205 * write the buffer to the inline inode.
 206 * If 'create' is set, we don't need to do the extra copy in the xattr
 207 * value since it is already handled by ext4_xattr_ibody_set.
 208 * That saves us one memcpy.
 209 */
 210static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc,
 211				   void *buffer, loff_t pos, unsigned int len)
 212{
 213	struct ext4_xattr_entry *entry;
 214	struct ext4_xattr_ibody_header *header;
 215	struct ext4_inode *raw_inode;
 216	int cp_len = 0;
 217
 218	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
 219		return;
 220
 221	BUG_ON(!EXT4_I(inode)->i_inline_off);
 222	BUG_ON(pos + len > EXT4_I(inode)->i_inline_size);
 223
 224	raw_inode = ext4_raw_inode(iloc);
 225	buffer += pos;
 226
 227	if (pos < EXT4_MIN_INLINE_DATA_SIZE) {
 228		cp_len = pos + len > EXT4_MIN_INLINE_DATA_SIZE ?
 229			 EXT4_MIN_INLINE_DATA_SIZE - pos : len;
 230		memcpy((void *)raw_inode->i_block + pos, buffer, cp_len);
 231
 232		len -= cp_len;
 233		buffer += cp_len;
 234		pos += cp_len;
 235	}
 236
 237	if (!len)
 238		return;
 239
 240	pos -= EXT4_MIN_INLINE_DATA_SIZE;
 241	header = IHDR(inode, raw_inode);
 242	entry = (struct ext4_xattr_entry *)((void *)raw_inode +
 243					    EXT4_I(inode)->i_inline_off);
 244
 245	memcpy((void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs) + pos,
 246	       buffer, len);
 247}
 248
 249static int ext4_create_inline_data(handle_t *handle,
 250				   struct inode *inode, unsigned len)
 251{
 252	int error;
 253	void *value = NULL;
 254	struct ext4_xattr_ibody_find is = {
 255		.s = { .not_found = -ENODATA, },
 256	};
 257	struct ext4_xattr_info i = {
 258		.name_index = EXT4_XATTR_INDEX_SYSTEM,
 259		.name = EXT4_XATTR_SYSTEM_DATA,
 260	};
 261
 262	error = ext4_get_inode_loc(inode, &is.iloc);
 263	if (error)
 264		return error;
 265
 266	BUFFER_TRACE(is.iloc.bh, "get_write_access");
 267	error = ext4_journal_get_write_access(handle, is.iloc.bh);
 268	if (error)
 269		goto out;
 270
 271	if (len > EXT4_MIN_INLINE_DATA_SIZE) {
 272		value = EXT4_ZERO_XATTR_VALUE;
 273		len -= EXT4_MIN_INLINE_DATA_SIZE;
 274	} else {
 275		value = "";
 276		len = 0;
 277	}
 278
 279	/* Insert the xttr entry. */
 280	i.value = value;
 281	i.value_len = len;
 282
 283	error = ext4_xattr_ibody_find(inode, &i, &is);
 284	if (error)
 285		goto out;
 286
 287	BUG_ON(!is.s.not_found);
 288
 289	error = ext4_xattr_ibody_set(handle, inode, &i, &is);
 290	if (error) {
 291		if (error == -ENOSPC)
 292			ext4_clear_inode_state(inode,
 293					       EXT4_STATE_MAY_INLINE_DATA);
 294		goto out;
 295	}
 296
 297	memset((void *)ext4_raw_inode(&is.iloc)->i_block,
 298		0, EXT4_MIN_INLINE_DATA_SIZE);
 299
 300	EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
 301				      (void *)ext4_raw_inode(&is.iloc));
 302	EXT4_I(inode)->i_inline_size = len + EXT4_MIN_INLINE_DATA_SIZE;
 303	ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
 304	ext4_set_inode_flag(inode, EXT4_INODE_INLINE_DATA);
 305	get_bh(is.iloc.bh);
 306	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
 307
 308out:
 309	brelse(is.iloc.bh);
 310	return error;
 311}
 312
 313static int ext4_update_inline_data(handle_t *handle, struct inode *inode,
 314				   unsigned int len)
 315{
 316	int error;
 317	void *value = NULL;
 318	struct ext4_xattr_ibody_find is = {
 319		.s = { .not_found = -ENODATA, },
 320	};
 321	struct ext4_xattr_info i = {
 322		.name_index = EXT4_XATTR_INDEX_SYSTEM,
 323		.name = EXT4_XATTR_SYSTEM_DATA,
 324	};
 325
 326	/* If the old space is ok, write the data directly. */
 327	if (len <= EXT4_I(inode)->i_inline_size)
 328		return 0;
 329
 330	error = ext4_get_inode_loc(inode, &is.iloc);
 331	if (error)
 332		return error;
 333
 334	error = ext4_xattr_ibody_find(inode, &i, &is);
 335	if (error)
 336		goto out;
 337
 338	BUG_ON(is.s.not_found);
 339
 340	len -= EXT4_MIN_INLINE_DATA_SIZE;
 341	value = kzalloc(len, GFP_NOFS);
 342	if (!value) {
 343		error = -ENOMEM;
 344		goto out;
 345	}
 346
 347	error = ext4_xattr_ibody_get(inode, i.name_index, i.name,
 348				     value, len);
 349	if (error == -ENODATA)
 350		goto out;
 351
 352	BUFFER_TRACE(is.iloc.bh, "get_write_access");
 353	error = ext4_journal_get_write_access(handle, is.iloc.bh);
 354	if (error)
 355		goto out;
 356
 357	/* Update the xattr entry. */
 358	i.value = value;
 359	i.value_len = len;
 360
 361	error = ext4_xattr_ibody_set(handle, inode, &i, &is);
 362	if (error)
 363		goto out;
 364
 365	EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
 366				      (void *)ext4_raw_inode(&is.iloc));
 367	EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
 368				le32_to_cpu(is.s.here->e_value_size);
 369	ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 370	get_bh(is.iloc.bh);
 371	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
 372
 373out:
 374	kfree(value);
 375	brelse(is.iloc.bh);
 376	return error;
 377}
 378
 379static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,
 380				    unsigned int len)
 381{
 382	int ret, size, no_expand;
 383	struct ext4_inode_info *ei = EXT4_I(inode);
 384
 385	if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA))
 386		return -ENOSPC;
 387
 388	size = ext4_get_max_inline_size(inode);
 389	if (size < len)
 390		return -ENOSPC;
 391
 392	ext4_write_lock_xattr(inode, &no_expand);
 393
 394	if (ei->i_inline_off)
 395		ret = ext4_update_inline_data(handle, inode, len);
 396	else
 397		ret = ext4_create_inline_data(handle, inode, len);
 398
 399	ext4_write_unlock_xattr(inode, &no_expand);
 400	return ret;
 401}
 402
 403static int ext4_destroy_inline_data_nolock(handle_t *handle,
 404					   struct inode *inode)
 405{
 406	struct ext4_inode_info *ei = EXT4_I(inode);
 407	struct ext4_xattr_ibody_find is = {
 408		.s = { .not_found = 0, },
 409	};
 410	struct ext4_xattr_info i = {
 411		.name_index = EXT4_XATTR_INDEX_SYSTEM,
 412		.name = EXT4_XATTR_SYSTEM_DATA,
 413		.value = NULL,
 414		.value_len = 0,
 415	};
 416	int error;
 417
 418	if (!ei->i_inline_off)
 419		return 0;
 420
 421	error = ext4_get_inode_loc(inode, &is.iloc);
 422	if (error)
 423		return error;
 424
 425	error = ext4_xattr_ibody_find(inode, &i, &is);
 426	if (error)
 427		goto out;
 428
 429	BUFFER_TRACE(is.iloc.bh, "get_write_access");
 430	error = ext4_journal_get_write_access(handle, is.iloc.bh);
 431	if (error)
 432		goto out;
 433
 434	error = ext4_xattr_ibody_set(handle, inode, &i, &is);
 435	if (error)
 436		goto out;
 437
 438	memset((void *)ext4_raw_inode(&is.iloc)->i_block,
 439		0, EXT4_MIN_INLINE_DATA_SIZE);
 440	memset(ei->i_data, 0, EXT4_MIN_INLINE_DATA_SIZE);
 441
 442	if (ext4_has_feature_extents(inode->i_sb)) {
 443		if (S_ISDIR(inode->i_mode) ||
 444		    S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) {
 445			ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
 446			ext4_ext_tree_init(handle, inode);
 447		}
 448	}
 449	ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA);
 450
 451	get_bh(is.iloc.bh);
 452	error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
 453
 454	EXT4_I(inode)->i_inline_off = 0;
 455	EXT4_I(inode)->i_inline_size = 0;
 456	ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 457out:
 458	brelse(is.iloc.bh);
 459	if (error == -ENODATA)
 460		error = 0;
 461	return error;
 462}
 463
 464static int ext4_read_inline_page(struct inode *inode, struct page *page)
 465{
 466	void *kaddr;
 467	int ret = 0;
 468	size_t len;
 469	struct ext4_iloc iloc;
 470
 471	BUG_ON(!PageLocked(page));
 472	BUG_ON(!ext4_has_inline_data(inode));
 473	BUG_ON(page->index);
 474
 475	if (!EXT4_I(inode)->i_inline_off) {
 476		ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
 477			     inode->i_ino);
 478		goto out;
 479	}
 480
 481	ret = ext4_get_inode_loc(inode, &iloc);
 482	if (ret)
 483		goto out;
 484
 485	len = min_t(size_t, ext4_get_inline_size(inode), i_size_read(inode));
 486	kaddr = kmap_atomic(page);
 487	ret = ext4_read_inline_data(inode, kaddr, len, &iloc);
 488	flush_dcache_page(page);
 489	kunmap_atomic(kaddr);
 490	zero_user_segment(page, len, PAGE_SIZE);
 491	SetPageUptodate(page);
 492	brelse(iloc.bh);
 493
 494out:
 495	return ret;
 496}
 497
 498int ext4_readpage_inline(struct inode *inode, struct page *page)
 499{
 500	int ret = 0;
 501
 502	down_read(&EXT4_I(inode)->xattr_sem);
 503	if (!ext4_has_inline_data(inode)) {
 504		up_read(&EXT4_I(inode)->xattr_sem);
 505		return -EAGAIN;
 506	}
 507
 508	/*
 509	 * Current inline data can only exist in the 1st page,
 510	 * So for all the other pages, just set them uptodate.
 511	 */
 512	if (!page->index)
 513		ret = ext4_read_inline_page(inode, page);
 514	else if (!PageUptodate(page)) {
 515		zero_user_segment(page, 0, PAGE_SIZE);
 516		SetPageUptodate(page);
 517	}
 518
 519	up_read(&EXT4_I(inode)->xattr_sem);
 520
 521	unlock_page(page);
 522	return ret >= 0 ? 0 : ret;
 523}
 524
 525static int ext4_convert_inline_data_to_extent(struct address_space *mapping,
 526					      struct inode *inode,
 527					      unsigned flags)
 528{
 529	int ret, needed_blocks, no_expand;
 530	handle_t *handle = NULL;
 531	int retries = 0, sem_held = 0;
 532	struct page *page = NULL;
 533	unsigned from, to;
 534	struct ext4_iloc iloc;
 535
 536	if (!ext4_has_inline_data(inode)) {
 537		/*
 538		 * clear the flag so that no new write
 539		 * will trap here again.
 540		 */
 541		ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 542		return 0;
 543	}
 544
 545	needed_blocks = ext4_writepage_trans_blocks(inode);
 546
 547	ret = ext4_get_inode_loc(inode, &iloc);
 548	if (ret)
 549		return ret;
 550
 551retry:
 552	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
 553	if (IS_ERR(handle)) {
 554		ret = PTR_ERR(handle);
 555		handle = NULL;
 556		goto out;
 557	}
 558
 559	/* We cannot recurse into the filesystem as the transaction is already
 560	 * started */
 561	flags |= AOP_FLAG_NOFS;
 562
 563	page = grab_cache_page_write_begin(mapping, 0, flags);
 564	if (!page) {
 565		ret = -ENOMEM;
 566		goto out;
 567	}
 568
 569	ext4_write_lock_xattr(inode, &no_expand);
 570	sem_held = 1;
 571	/* If some one has already done this for us, just exit. */
 572	if (!ext4_has_inline_data(inode)) {
 573		ret = 0;
 574		goto out;
 575	}
 576
 577	from = 0;
 578	to = ext4_get_inline_size(inode);
 579	if (!PageUptodate(page)) {
 580		ret = ext4_read_inline_page(inode, page);
 581		if (ret < 0)
 582			goto out;
 583	}
 584
 585	ret = ext4_destroy_inline_data_nolock(handle, inode);
 586	if (ret)
 587		goto out;
 588
 589	if (ext4_should_dioread_nolock(inode)) {
 590		ret = __block_write_begin(page, from, to,
 591					  ext4_get_block_unwritten);
 592	} else
 593		ret = __block_write_begin(page, from, to, ext4_get_block);
 594
 595	if (!ret && ext4_should_journal_data(inode)) {
 596		ret = ext4_walk_page_buffers(handle, page_buffers(page),
 597					     from, to, NULL,
 598					     do_journal_get_write_access);
 599	}
 600
 601	if (ret) {
 602		unlock_page(page);
 603		put_page(page);
 604		page = NULL;
 605		ext4_orphan_add(handle, inode);
 606		ext4_write_unlock_xattr(inode, &no_expand);
 607		sem_held = 0;
 608		ext4_journal_stop(handle);
 609		handle = NULL;
 610		ext4_truncate_failed_write(inode);
 611		/*
 612		 * If truncate failed early the inode might
 613		 * still be on the orphan list; we need to
 614		 * make sure the inode is removed from the
 615		 * orphan list in that case.
 616		 */
 617		if (inode->i_nlink)
 618			ext4_orphan_del(NULL, inode);
 619	}
 620
 621	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
 622		goto retry;
 623
 624	if (page)
 625		block_commit_write(page, from, to);
 626out:
 627	if (page) {
 628		unlock_page(page);
 629		put_page(page);
 630	}
 631	if (sem_held)
 632		ext4_write_unlock_xattr(inode, &no_expand);
 633	if (handle)
 634		ext4_journal_stop(handle);
 635	brelse(iloc.bh);
 636	return ret;
 637}
 638
 639/*
 640 * Try to write data in the inode.
 641 * If the inode has inline data, check whether the new write can be
 642 * in the inode also. If not, create the page the handle, move the data
 643 * to the page make it update and let the later codes create extent for it.
 644 */
 645int ext4_try_to_write_inline_data(struct address_space *mapping,
 646				  struct inode *inode,
 647				  loff_t pos, unsigned len,
 648				  unsigned flags,
 649				  struct page **pagep)
 650{
 651	int ret;
 652	handle_t *handle;
 653	struct page *page;
 654	struct ext4_iloc iloc;
 655
 656	if (pos + len > ext4_get_max_inline_size(inode))
 657		goto convert;
 658
 659	ret = ext4_get_inode_loc(inode, &iloc);
 660	if (ret)
 661		return ret;
 662
 663	/*
 664	 * The possible write could happen in the inode,
 665	 * so try to reserve the space in inode first.
 666	 */
 667	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
 668	if (IS_ERR(handle)) {
 669		ret = PTR_ERR(handle);
 670		handle = NULL;
 671		goto out;
 672	}
 673
 674	ret = ext4_prepare_inline_data(handle, inode, pos + len);
 675	if (ret && ret != -ENOSPC)
 676		goto out;
 677
 678	/* We don't have space in inline inode, so convert it to extent. */
 679	if (ret == -ENOSPC) {
 680		ext4_journal_stop(handle);
 681		brelse(iloc.bh);
 682		goto convert;
 683	}
 684
 685	ret = ext4_journal_get_write_access(handle, iloc.bh);
 686	if (ret)
 687		goto out;
 688
 689	flags |= AOP_FLAG_NOFS;
 690
 691	page = grab_cache_page_write_begin(mapping, 0, flags);
 692	if (!page) {
 693		ret = -ENOMEM;
 694		goto out;
 695	}
 696
 697	*pagep = page;
 698	down_read(&EXT4_I(inode)->xattr_sem);
 699	if (!ext4_has_inline_data(inode)) {
 700		ret = 0;
 701		unlock_page(page);
 702		put_page(page);
 703		goto out_up_read;
 704	}
 705
 706	if (!PageUptodate(page)) {
 707		ret = ext4_read_inline_page(inode, page);
 708		if (ret < 0) {
 709			unlock_page(page);
 710			put_page(page);
 711			goto out_up_read;
 712		}
 713	}
 714
 715	ret = 1;
 716	handle = NULL;
 717out_up_read:
 718	up_read(&EXT4_I(inode)->xattr_sem);
 719out:
 720	if (handle && (ret != 1))
 721		ext4_journal_stop(handle);
 722	brelse(iloc.bh);
 723	return ret;
 724convert:
 725	return ext4_convert_inline_data_to_extent(mapping,
 726						  inode, flags);
 727}
 728
 729int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len,
 730			       unsigned copied, struct page *page)
 731{
 732	int ret, no_expand;
 733	void *kaddr;
 734	struct ext4_iloc iloc;
 735
 736	if (unlikely(copied < len) && !PageUptodate(page))
 737		return 0;
 
 
 
 
 738
 739	ret = ext4_get_inode_loc(inode, &iloc);
 740	if (ret) {
 741		ext4_std_error(inode->i_sb, ret);
 742		return ret;
 
 743	}
 744
 745	ext4_write_lock_xattr(inode, &no_expand);
 746	BUG_ON(!ext4_has_inline_data(inode));
 747
 748	/*
 749	 * ei->i_inline_off may have changed since ext4_write_begin()
 750	 * called ext4_try_to_write_inline_data()
 751	 */
 752	(void) ext4_find_inline_data_nolock(inode);
 753
 754	kaddr = kmap_atomic(page);
 755	ext4_write_inline_data(inode, &iloc, kaddr, pos, copied);
 756	kunmap_atomic(kaddr);
 757	SetPageUptodate(page);
 758	/* clear page dirty so that writepages wouldn't work for us. */
 759	ClearPageDirty(page);
 760
 761	ext4_write_unlock_xattr(inode, &no_expand);
 762	brelse(iloc.bh);
 763	mark_inode_dirty(inode);
 764
 765	return copied;
 766}
 767
 768struct buffer_head *
 769ext4_journalled_write_inline_data(struct inode *inode,
 770				  unsigned len,
 771				  struct page *page)
 772{
 773	int ret, no_expand;
 774	void *kaddr;
 775	struct ext4_iloc iloc;
 776
 777	ret = ext4_get_inode_loc(inode, &iloc);
 778	if (ret) {
 779		ext4_std_error(inode->i_sb, ret);
 780		return NULL;
 781	}
 782
 783	ext4_write_lock_xattr(inode, &no_expand);
 784	kaddr = kmap_atomic(page);
 785	ext4_write_inline_data(inode, &iloc, kaddr, 0, len);
 786	kunmap_atomic(kaddr);
 787	ext4_write_unlock_xattr(inode, &no_expand);
 788
 789	return iloc.bh;
 790}
 791
 792/*
 793 * Try to make the page cache and handle ready for the inline data case.
 794 * We can call this function in 2 cases:
 795 * 1. The inode is created and the first write exceeds inline size. We can
 796 *    clear the inode state safely.
 797 * 2. The inode has inline data, then we need to read the data, make it
 798 *    update and dirty so that ext4_da_writepages can handle it. We don't
 799 *    need to start the journal since the file's metadata isn't changed now.
 800 */
 801static int ext4_da_convert_inline_data_to_extent(struct address_space *mapping,
 802						 struct inode *inode,
 803						 unsigned flags,
 804						 void **fsdata)
 805{
 806	int ret = 0, inline_size;
 807	struct page *page;
 808
 809	page = grab_cache_page_write_begin(mapping, 0, flags);
 810	if (!page)
 811		return -ENOMEM;
 812
 813	down_read(&EXT4_I(inode)->xattr_sem);
 814	if (!ext4_has_inline_data(inode)) {
 815		ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 816		goto out;
 817	}
 818
 819	inline_size = ext4_get_inline_size(inode);
 820
 821	if (!PageUptodate(page)) {
 822		ret = ext4_read_inline_page(inode, page);
 823		if (ret < 0)
 824			goto out;
 825	}
 826
 827	ret = __block_write_begin(page, 0, inline_size,
 828				  ext4_da_get_block_prep);
 829	if (ret) {
 830		up_read(&EXT4_I(inode)->xattr_sem);
 831		unlock_page(page);
 832		put_page(page);
 833		ext4_truncate_failed_write(inode);
 834		return ret;
 835	}
 836
 837	SetPageDirty(page);
 838	SetPageUptodate(page);
 839	ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
 840	*fsdata = (void *)CONVERT_INLINE_DATA;
 841
 842out:
 843	up_read(&EXT4_I(inode)->xattr_sem);
 844	if (page) {
 845		unlock_page(page);
 846		put_page(page);
 847	}
 848	return ret;
 849}
 850
 851/*
 852 * Prepare the write for the inline data.
 853 * If the data can be written into the inode, we just read
 854 * the page and make it uptodate, and start the journal.
 855 * Otherwise read the page, makes it dirty so that it can be
 856 * handle in writepages(the i_disksize update is left to the
 857 * normal ext4_da_write_end).
 858 */
 859int ext4_da_write_inline_data_begin(struct address_space *mapping,
 860				    struct inode *inode,
 861				    loff_t pos, unsigned len,
 862				    unsigned flags,
 863				    struct page **pagep,
 864				    void **fsdata)
 865{
 866	int ret, inline_size;
 867	handle_t *handle;
 868	struct page *page;
 869	struct ext4_iloc iloc;
 870	int retries = 0;
 871
 872	ret = ext4_get_inode_loc(inode, &iloc);
 873	if (ret)
 874		return ret;
 875
 876retry_journal:
 877	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
 878	if (IS_ERR(handle)) {
 879		ret = PTR_ERR(handle);
 880		goto out;
 881	}
 882
 883	inline_size = ext4_get_max_inline_size(inode);
 884
 885	ret = -ENOSPC;
 886	if (inline_size >= pos + len) {
 887		ret = ext4_prepare_inline_data(handle, inode, pos + len);
 888		if (ret && ret != -ENOSPC)
 889			goto out_journal;
 890	}
 891
 892	/*
 893	 * We cannot recurse into the filesystem as the transaction
 894	 * is already started.
 895	 */
 896	flags |= AOP_FLAG_NOFS;
 897
 898	if (ret == -ENOSPC) {
 899		ext4_journal_stop(handle);
 900		ret = ext4_da_convert_inline_data_to_extent(mapping,
 901							    inode,
 902							    flags,
 903							    fsdata);
 
 904		if (ret == -ENOSPC &&
 905		    ext4_should_retry_alloc(inode->i_sb, &retries))
 906			goto retry_journal;
 907		goto out;
 908	}
 909
 
 910	page = grab_cache_page_write_begin(mapping, 0, flags);
 911	if (!page) {
 912		ret = -ENOMEM;
 913		goto out_journal;
 914	}
 915
 916	down_read(&EXT4_I(inode)->xattr_sem);
 917	if (!ext4_has_inline_data(inode)) {
 918		ret = 0;
 919		goto out_release_page;
 920	}
 921
 922	if (!PageUptodate(page)) {
 923		ret = ext4_read_inline_page(inode, page);
 924		if (ret < 0)
 925			goto out_release_page;
 926	}
 927	ret = ext4_journal_get_write_access(handle, iloc.bh);
 928	if (ret)
 929		goto out_release_page;
 930
 931	up_read(&EXT4_I(inode)->xattr_sem);
 932	*pagep = page;
 933	brelse(iloc.bh);
 934	return 1;
 935out_release_page:
 936	up_read(&EXT4_I(inode)->xattr_sem);
 937	unlock_page(page);
 938	put_page(page);
 939out_journal:
 940	ext4_journal_stop(handle);
 941out:
 942	brelse(iloc.bh);
 943	return ret;
 944}
 945
 946int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
 947				  unsigned len, unsigned copied,
 948				  struct page *page)
 949{
 
 950	int ret;
 951
 952	ret = ext4_write_inline_data_end(inode, pos, len, copied, page);
 953	if (ret < 0) {
 954		unlock_page(page);
 955		put_page(page);
 956		return ret;
 957	}
 958	copied = ret;
 959
 960	/*
 961	 * No need to use i_size_read() here, the i_size
 962	 * cannot change under us because we hold i_mutex.
 963	 *
 964	 * But it's important to update i_size while still holding page lock:
 965	 * page writeout could otherwise come in and zero beyond i_size.
 966	 */
 967	if (pos+copied > inode->i_size)
 968		i_size_write(inode, pos+copied);
 
 
 969	unlock_page(page);
 970	put_page(page);
 971
 972	/*
 973	 * Don't mark the inode dirty under page lock. First, it unnecessarily
 974	 * makes the holding time of page lock longer. Second, it forces lock
 975	 * ordering of page lock and transaction start for journaling
 976	 * filesystems.
 977	 */
 978	mark_inode_dirty(inode);
 
 979
 980	return copied;
 981}
 982
 983#ifdef INLINE_DIR_DEBUG
 984void ext4_show_inline_dir(struct inode *dir, struct buffer_head *bh,
 985			  void *inline_start, int inline_size)
 986{
 987	int offset;
 988	unsigned short de_len;
 989	struct ext4_dir_entry_2 *de = inline_start;
 990	void *dlimit = inline_start + inline_size;
 991
 992	trace_printk("inode %lu\n", dir->i_ino);
 993	offset = 0;
 994	while ((void *)de < dlimit) {
 995		de_len = ext4_rec_len_from_disk(de->rec_len, inline_size);
 996		trace_printk("de: off %u rlen %u name %.*s nlen %u ino %u\n",
 997			     offset, de_len, de->name_len, de->name,
 998			     de->name_len, le32_to_cpu(de->inode));
 999		if (ext4_check_dir_entry(dir, NULL, de, bh,
1000					 inline_start, inline_size, offset))
1001			BUG();
1002
1003		offset += de_len;
1004		de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1005	}
1006}
1007#else
1008#define ext4_show_inline_dir(dir, bh, inline_start, inline_size)
1009#endif
1010
1011/*
1012 * Add a new entry into a inline dir.
1013 * It will return -ENOSPC if no space is available, and -EIO
1014 * and -EEXIST if directory entry already exists.
1015 */
1016static int ext4_add_dirent_to_inline(handle_t *handle,
1017				     struct ext4_filename *fname,
1018				     struct inode *dir,
1019				     struct inode *inode,
1020				     struct ext4_iloc *iloc,
1021				     void *inline_start, int inline_size)
1022{
1023	int		err;
1024	struct ext4_dir_entry_2 *de;
1025
1026	err = ext4_find_dest_de(dir, inode, iloc->bh, inline_start,
1027				inline_size, fname, &de);
1028	if (err)
1029		return err;
1030
1031	BUFFER_TRACE(iloc->bh, "get_write_access");
1032	err = ext4_journal_get_write_access(handle, iloc->bh);
1033	if (err)
1034		return err;
1035	ext4_insert_dentry(dir, inode, de, inline_size, fname);
1036
1037	ext4_show_inline_dir(dir, iloc->bh, inline_start, inline_size);
1038
1039	/*
1040	 * XXX shouldn't update any times until successful
1041	 * completion of syscall, but too many callers depend
1042	 * on this.
1043	 *
1044	 * XXX similarly, too many callers depend on
1045	 * ext4_new_inode() setting the times, but error
1046	 * recovery deletes the inode, so the worst that can
1047	 * happen is that the times are slightly out of date
1048	 * and/or different from the directory change time.
1049	 */
1050	dir->i_mtime = dir->i_ctime = current_time(dir);
1051	ext4_update_dx_flag(dir);
1052	inode_inc_iversion(dir);
1053	return 1;
1054}
1055
1056static void *ext4_get_inline_xattr_pos(struct inode *inode,
1057				       struct ext4_iloc *iloc)
1058{
1059	struct ext4_xattr_entry *entry;
1060	struct ext4_xattr_ibody_header *header;
1061
1062	BUG_ON(!EXT4_I(inode)->i_inline_off);
1063
1064	header = IHDR(inode, ext4_raw_inode(iloc));
1065	entry = (struct ext4_xattr_entry *)((void *)ext4_raw_inode(iloc) +
1066					    EXT4_I(inode)->i_inline_off);
1067
1068	return (void *)IFIRST(header) + le16_to_cpu(entry->e_value_offs);
1069}
1070
1071/* Set the final de to cover the whole block. */
1072static void ext4_update_final_de(void *de_buf, int old_size, int new_size)
1073{
1074	struct ext4_dir_entry_2 *de, *prev_de;
1075	void *limit;
1076	int de_len;
1077
1078	de = (struct ext4_dir_entry_2 *)de_buf;
1079	if (old_size) {
1080		limit = de_buf + old_size;
1081		do {
1082			prev_de = de;
1083			de_len = ext4_rec_len_from_disk(de->rec_len, old_size);
1084			de_buf += de_len;
1085			de = (struct ext4_dir_entry_2 *)de_buf;
1086		} while (de_buf < limit);
1087
1088		prev_de->rec_len = ext4_rec_len_to_disk(de_len + new_size -
1089							old_size, new_size);
1090	} else {
1091		/* this is just created, so create an empty entry. */
1092		de->inode = 0;
1093		de->rec_len = ext4_rec_len_to_disk(new_size, new_size);
1094	}
1095}
1096
1097static int ext4_update_inline_dir(handle_t *handle, struct inode *dir,
1098				  struct ext4_iloc *iloc)
1099{
1100	int ret;
1101	int old_size = EXT4_I(dir)->i_inline_size - EXT4_MIN_INLINE_DATA_SIZE;
1102	int new_size = get_max_inline_xattr_value_size(dir, iloc);
1103
1104	if (new_size - old_size <= ext4_dir_rec_len(1, NULL))
1105		return -ENOSPC;
1106
1107	ret = ext4_update_inline_data(handle, dir,
1108				      new_size + EXT4_MIN_INLINE_DATA_SIZE);
1109	if (ret)
1110		return ret;
1111
1112	ext4_update_final_de(ext4_get_inline_xattr_pos(dir, iloc), old_size,
1113			     EXT4_I(dir)->i_inline_size -
1114						EXT4_MIN_INLINE_DATA_SIZE);
1115	dir->i_size = EXT4_I(dir)->i_disksize = EXT4_I(dir)->i_inline_size;
1116	return 0;
1117}
1118
1119static void ext4_restore_inline_data(handle_t *handle, struct inode *inode,
1120				     struct ext4_iloc *iloc,
1121				     void *buf, int inline_size)
1122{
1123	ext4_create_inline_data(handle, inode, inline_size);
1124	ext4_write_inline_data(inode, iloc, buf, 0, inline_size);
1125	ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1126}
1127
1128static int ext4_finish_convert_inline_dir(handle_t *handle,
1129					  struct inode *inode,
1130					  struct buffer_head *dir_block,
1131					  void *buf,
1132					  int inline_size)
1133{
1134	int err, csum_size = 0, header_size = 0;
1135	struct ext4_dir_entry_2 *de;
 
1136	void *target = dir_block->b_data;
1137
1138	/*
1139	 * First create "." and ".." and then copy the dir information
1140	 * back to the block.
1141	 */
1142	de = (struct ext4_dir_entry_2 *)target;
1143	de = ext4_init_dot_dotdot(inode, de,
1144		inode->i_sb->s_blocksize, csum_size,
1145		le32_to_cpu(((struct ext4_dir_entry_2 *)buf)->inode), 1);
1146	header_size = (void *)de - target;
1147
1148	memcpy((void *)de, buf + EXT4_INLINE_DOTDOT_SIZE,
1149		inline_size - EXT4_INLINE_DOTDOT_SIZE);
1150
1151	if (ext4_has_metadata_csum(inode->i_sb))
1152		csum_size = sizeof(struct ext4_dir_entry_tail);
1153
1154	inode->i_size = inode->i_sb->s_blocksize;
1155	i_size_write(inode, inode->i_sb->s_blocksize);
1156	EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
1157	ext4_update_final_de(dir_block->b_data,
1158			inline_size - EXT4_INLINE_DOTDOT_SIZE + header_size,
1159			inode->i_sb->s_blocksize - csum_size);
1160
1161	if (csum_size)
1162		ext4_initialize_dirent_tail(dir_block,
1163					    inode->i_sb->s_blocksize);
 
 
1164	set_buffer_uptodate(dir_block);
1165	err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
1166	if (err)
1167		return err;
1168	set_buffer_verified(dir_block);
1169	return ext4_mark_inode_dirty(handle, inode);
1170}
1171
1172static int ext4_convert_inline_data_nolock(handle_t *handle,
1173					   struct inode *inode,
1174					   struct ext4_iloc *iloc)
1175{
1176	int error;
1177	void *buf = NULL;
1178	struct buffer_head *data_bh = NULL;
1179	struct ext4_map_blocks map;
1180	int inline_size;
1181
1182	inline_size = ext4_get_inline_size(inode);
1183	buf = kmalloc(inline_size, GFP_NOFS);
1184	if (!buf) {
1185		error = -ENOMEM;
1186		goto out;
1187	}
1188
1189	error = ext4_read_inline_data(inode, buf, inline_size, iloc);
1190	if (error < 0)
1191		goto out;
1192
1193	/*
1194	 * Make sure the inline directory entries pass checks before we try to
1195	 * convert them, so that we avoid touching stuff that needs fsck.
1196	 */
1197	if (S_ISDIR(inode->i_mode)) {
1198		error = ext4_check_all_de(inode, iloc->bh,
1199					buf + EXT4_INLINE_DOTDOT_SIZE,
1200					inline_size - EXT4_INLINE_DOTDOT_SIZE);
1201		if (error)
1202			goto out;
1203	}
1204
1205	error = ext4_destroy_inline_data_nolock(handle, inode);
1206	if (error)
1207		goto out;
1208
1209	map.m_lblk = 0;
1210	map.m_len = 1;
1211	map.m_flags = 0;
1212	error = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_CREATE);
1213	if (error < 0)
1214		goto out_restore;
1215	if (!(map.m_flags & EXT4_MAP_MAPPED)) {
1216		error = -EIO;
1217		goto out_restore;
1218	}
1219
1220	data_bh = sb_getblk(inode->i_sb, map.m_pblk);
1221	if (!data_bh) {
1222		error = -ENOMEM;
1223		goto out_restore;
1224	}
1225
1226	lock_buffer(data_bh);
1227	error = ext4_journal_get_create_access(handle, data_bh);
1228	if (error) {
1229		unlock_buffer(data_bh);
1230		error = -EIO;
1231		goto out_restore;
1232	}
1233	memset(data_bh->b_data, 0, inode->i_sb->s_blocksize);
1234
1235	if (!S_ISDIR(inode->i_mode)) {
1236		memcpy(data_bh->b_data, buf, inline_size);
1237		set_buffer_uptodate(data_bh);
1238		error = ext4_handle_dirty_metadata(handle,
1239						   inode, data_bh);
1240	} else {
1241		error = ext4_finish_convert_inline_dir(handle, inode, data_bh,
1242						       buf, inline_size);
1243	}
1244
1245	unlock_buffer(data_bh);
1246out_restore:
1247	if (error)
1248		ext4_restore_inline_data(handle, inode, iloc, buf, inline_size);
1249
1250out:
1251	brelse(data_bh);
1252	kfree(buf);
1253	return error;
1254}
1255
1256/*
1257 * Try to add the new entry to the inline data.
1258 * If succeeds, return 0. If not, extended the inline dir and copied data to
1259 * the new created block.
1260 */
1261int ext4_try_add_inline_entry(handle_t *handle, struct ext4_filename *fname,
1262			      struct inode *dir, struct inode *inode)
1263{
1264	int ret, ret2, inline_size, no_expand;
1265	void *inline_start;
1266	struct ext4_iloc iloc;
1267
1268	ret = ext4_get_inode_loc(dir, &iloc);
1269	if (ret)
1270		return ret;
1271
1272	ext4_write_lock_xattr(dir, &no_expand);
1273	if (!ext4_has_inline_data(dir))
1274		goto out;
1275
1276	inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
1277						 EXT4_INLINE_DOTDOT_SIZE;
1278	inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
1279
1280	ret = ext4_add_dirent_to_inline(handle, fname, dir, inode, &iloc,
1281					inline_start, inline_size);
1282	if (ret != -ENOSPC)
1283		goto out;
1284
1285	/* check whether it can be inserted to inline xattr space. */
1286	inline_size = EXT4_I(dir)->i_inline_size -
1287			EXT4_MIN_INLINE_DATA_SIZE;
1288	if (!inline_size) {
1289		/* Try to use the xattr space.*/
1290		ret = ext4_update_inline_dir(handle, dir, &iloc);
1291		if (ret && ret != -ENOSPC)
1292			goto out;
1293
1294		inline_size = EXT4_I(dir)->i_inline_size -
1295				EXT4_MIN_INLINE_DATA_SIZE;
1296	}
1297
1298	if (inline_size) {
1299		inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1300
1301		ret = ext4_add_dirent_to_inline(handle, fname, dir,
1302						inode, &iloc, inline_start,
1303						inline_size);
1304
1305		if (ret != -ENOSPC)
1306			goto out;
1307	}
1308
1309	/*
1310	 * The inline space is filled up, so create a new block for it.
1311	 * As the extent tree will be created, we have to save the inline
1312	 * dir first.
1313	 */
1314	ret = ext4_convert_inline_data_nolock(handle, dir, &iloc);
1315
1316out:
1317	ext4_write_unlock_xattr(dir, &no_expand);
1318	ret2 = ext4_mark_inode_dirty(handle, dir);
1319	if (unlikely(ret2 && !ret))
1320		ret = ret2;
1321	brelse(iloc.bh);
1322	return ret;
1323}
1324
1325/*
1326 * This function fills a red-black tree with information from an
1327 * inlined dir.  It returns the number directory entries loaded
1328 * into the tree.  If there is an error it is returned in err.
1329 */
1330int ext4_inlinedir_to_tree(struct file *dir_file,
1331			   struct inode *dir, ext4_lblk_t block,
1332			   struct dx_hash_info *hinfo,
1333			   __u32 start_hash, __u32 start_minor_hash,
1334			   int *has_inline_data)
1335{
1336	int err = 0, count = 0;
1337	unsigned int parent_ino;
1338	int pos;
1339	struct ext4_dir_entry_2 *de;
1340	struct inode *inode = file_inode(dir_file);
1341	int ret, inline_size = 0;
1342	struct ext4_iloc iloc;
1343	void *dir_buf = NULL;
1344	struct ext4_dir_entry_2 fake;
1345	struct fscrypt_str tmp_str;
1346
1347	ret = ext4_get_inode_loc(inode, &iloc);
1348	if (ret)
1349		return ret;
1350
1351	down_read(&EXT4_I(inode)->xattr_sem);
1352	if (!ext4_has_inline_data(inode)) {
1353		up_read(&EXT4_I(inode)->xattr_sem);
1354		*has_inline_data = 0;
1355		goto out;
1356	}
1357
1358	inline_size = ext4_get_inline_size(inode);
1359	dir_buf = kmalloc(inline_size, GFP_NOFS);
1360	if (!dir_buf) {
1361		ret = -ENOMEM;
1362		up_read(&EXT4_I(inode)->xattr_sem);
1363		goto out;
1364	}
1365
1366	ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1367	up_read(&EXT4_I(inode)->xattr_sem);
1368	if (ret < 0)
1369		goto out;
1370
1371	pos = 0;
1372	parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1373	while (pos < inline_size) {
1374		/*
1375		 * As inlined dir doesn't store any information about '.' and
1376		 * only the inode number of '..' is stored, we have to handle
1377		 * them differently.
1378		 */
1379		if (pos == 0) {
1380			fake.inode = cpu_to_le32(inode->i_ino);
1381			fake.name_len = 1;
1382			strcpy(fake.name, ".");
1383			fake.rec_len = ext4_rec_len_to_disk(
1384					  ext4_dir_rec_len(fake.name_len, NULL),
1385					  inline_size);
1386			ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1387			de = &fake;
1388			pos = EXT4_INLINE_DOTDOT_OFFSET;
1389		} else if (pos == EXT4_INLINE_DOTDOT_OFFSET) {
1390			fake.inode = cpu_to_le32(parent_ino);
1391			fake.name_len = 2;
1392			strcpy(fake.name, "..");
1393			fake.rec_len = ext4_rec_len_to_disk(
1394					  ext4_dir_rec_len(fake.name_len, NULL),
1395					  inline_size);
1396			ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1397			de = &fake;
1398			pos = EXT4_INLINE_DOTDOT_SIZE;
1399		} else {
1400			de = (struct ext4_dir_entry_2 *)(dir_buf + pos);
1401			pos += ext4_rec_len_from_disk(de->rec_len, inline_size);
1402			if (ext4_check_dir_entry(inode, dir_file, de,
1403					 iloc.bh, dir_buf,
1404					 inline_size, pos)) {
1405				ret = count;
1406				goto out;
1407			}
1408		}
1409
1410		if (ext4_hash_in_dirent(dir)) {
1411			hinfo->hash = EXT4_DIRENT_HASH(de);
1412			hinfo->minor_hash = EXT4_DIRENT_MINOR_HASH(de);
1413		} else {
1414			ext4fs_dirhash(dir, de->name, de->name_len, hinfo);
1415		}
1416		if ((hinfo->hash < start_hash) ||
1417		    ((hinfo->hash == start_hash) &&
1418		     (hinfo->minor_hash < start_minor_hash)))
1419			continue;
1420		if (de->inode == 0)
1421			continue;
1422		tmp_str.name = de->name;
1423		tmp_str.len = de->name_len;
1424		err = ext4_htree_store_dirent(dir_file, hinfo->hash,
1425					      hinfo->minor_hash, de, &tmp_str);
1426		if (err) {
1427			ret = err;
1428			goto out;
1429		}
1430		count++;
1431	}
1432	ret = count;
1433out:
1434	kfree(dir_buf);
1435	brelse(iloc.bh);
1436	return ret;
1437}
1438
1439/*
1440 * So this function is called when the volume is mkfsed with
1441 * dir_index disabled. In order to keep f_pos persistent
1442 * after we convert from an inlined dir to a blocked based,
1443 * we just pretend that we are a normal dir and return the
1444 * offset as if '.' and '..' really take place.
1445 *
1446 */
1447int ext4_read_inline_dir(struct file *file,
1448			 struct dir_context *ctx,
1449			 int *has_inline_data)
1450{
1451	unsigned int offset, parent_ino;
1452	int i;
1453	struct ext4_dir_entry_2 *de;
1454	struct super_block *sb;
1455	struct inode *inode = file_inode(file);
1456	int ret, inline_size = 0;
1457	struct ext4_iloc iloc;
1458	void *dir_buf = NULL;
1459	int dotdot_offset, dotdot_size, extra_offset, extra_size;
1460
1461	ret = ext4_get_inode_loc(inode, &iloc);
1462	if (ret)
1463		return ret;
1464
1465	down_read(&EXT4_I(inode)->xattr_sem);
1466	if (!ext4_has_inline_data(inode)) {
1467		up_read(&EXT4_I(inode)->xattr_sem);
1468		*has_inline_data = 0;
1469		goto out;
1470	}
1471
1472	inline_size = ext4_get_inline_size(inode);
1473	dir_buf = kmalloc(inline_size, GFP_NOFS);
1474	if (!dir_buf) {
1475		ret = -ENOMEM;
1476		up_read(&EXT4_I(inode)->xattr_sem);
1477		goto out;
1478	}
1479
1480	ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1481	up_read(&EXT4_I(inode)->xattr_sem);
1482	if (ret < 0)
1483		goto out;
1484
1485	ret = 0;
1486	sb = inode->i_sb;
1487	parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1488	offset = ctx->pos;
1489
1490	/*
1491	 * dotdot_offset and dotdot_size is the real offset and
1492	 * size for ".." and "." if the dir is block based while
1493	 * the real size for them are only EXT4_INLINE_DOTDOT_SIZE.
1494	 * So we will use extra_offset and extra_size to indicate them
1495	 * during the inline dir iteration.
1496	 */
1497	dotdot_offset = ext4_dir_rec_len(1, NULL);
1498	dotdot_size = dotdot_offset + ext4_dir_rec_len(2, NULL);
1499	extra_offset = dotdot_size - EXT4_INLINE_DOTDOT_SIZE;
1500	extra_size = extra_offset + inline_size;
1501
1502	/*
1503	 * If the version has changed since the last call to
1504	 * readdir(2), then we might be pointing to an invalid
1505	 * dirent right now.  Scan from the start of the inline
1506	 * dir to make sure.
1507	 */
1508	if (!inode_eq_iversion(inode, file->f_version)) {
1509		for (i = 0; i < extra_size && i < offset;) {
1510			/*
1511			 * "." is with offset 0 and
1512			 * ".." is dotdot_offset.
1513			 */
1514			if (!i) {
1515				i = dotdot_offset;
1516				continue;
1517			} else if (i == dotdot_offset) {
1518				i = dotdot_size;
1519				continue;
1520			}
1521			/* for other entry, the real offset in
1522			 * the buf has to be tuned accordingly.
1523			 */
1524			de = (struct ext4_dir_entry_2 *)
1525				(dir_buf + i - extra_offset);
1526			/* It's too expensive to do a full
1527			 * dirent test each time round this
1528			 * loop, but we do have to test at
1529			 * least that it is non-zero.  A
1530			 * failure will be detected in the
1531			 * dirent test below. */
1532			if (ext4_rec_len_from_disk(de->rec_len, extra_size)
1533				< ext4_dir_rec_len(1, NULL))
1534				break;
1535			i += ext4_rec_len_from_disk(de->rec_len,
1536						    extra_size);
1537		}
1538		offset = i;
1539		ctx->pos = offset;
1540		file->f_version = inode_query_iversion(inode);
1541	}
1542
1543	while (ctx->pos < extra_size) {
1544		if (ctx->pos == 0) {
1545			if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR))
1546				goto out;
1547			ctx->pos = dotdot_offset;
1548			continue;
1549		}
1550
1551		if (ctx->pos == dotdot_offset) {
1552			if (!dir_emit(ctx, "..", 2, parent_ino, DT_DIR))
1553				goto out;
1554			ctx->pos = dotdot_size;
1555			continue;
1556		}
1557
1558		de = (struct ext4_dir_entry_2 *)
1559			(dir_buf + ctx->pos - extra_offset);
1560		if (ext4_check_dir_entry(inode, file, de, iloc.bh, dir_buf,
1561					 extra_size, ctx->pos))
1562			goto out;
1563		if (le32_to_cpu(de->inode)) {
1564			if (!dir_emit(ctx, de->name, de->name_len,
1565				      le32_to_cpu(de->inode),
1566				      get_dtype(sb, de->file_type)))
1567				goto out;
1568		}
1569		ctx->pos += ext4_rec_len_from_disk(de->rec_len, extra_size);
1570	}
1571out:
1572	kfree(dir_buf);
1573	brelse(iloc.bh);
1574	return ret;
1575}
1576
1577struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
1578					struct ext4_dir_entry_2 **parent_de,
1579					int *retval)
1580{
1581	struct ext4_iloc iloc;
1582
1583	*retval = ext4_get_inode_loc(inode, &iloc);
1584	if (*retval)
1585		return NULL;
1586
1587	*parent_de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
1588
1589	return iloc.bh;
1590}
1591
1592/*
1593 * Try to create the inline data for the new dir.
1594 * If it succeeds, return 0, otherwise return the error.
1595 * In case of ENOSPC, the caller should create the normal disk layout dir.
1596 */
1597int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent,
1598			       struct inode *inode)
1599{
1600	int ret, inline_size = EXT4_MIN_INLINE_DATA_SIZE;
1601	struct ext4_iloc iloc;
1602	struct ext4_dir_entry_2 *de;
1603
1604	ret = ext4_get_inode_loc(inode, &iloc);
1605	if (ret)
1606		return ret;
1607
1608	ret = ext4_prepare_inline_data(handle, inode, inline_size);
1609	if (ret)
1610		goto out;
1611
1612	/*
1613	 * For inline dir, we only save the inode information for the ".."
1614	 * and create a fake dentry to cover the left space.
1615	 */
1616	de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
1617	de->inode = cpu_to_le32(parent->i_ino);
1618	de = (struct ext4_dir_entry_2 *)((void *)de + EXT4_INLINE_DOTDOT_SIZE);
1619	de->inode = 0;
1620	de->rec_len = ext4_rec_len_to_disk(
1621				inline_size - EXT4_INLINE_DOTDOT_SIZE,
1622				inline_size);
1623	set_nlink(inode, 2);
1624	inode->i_size = EXT4_I(inode)->i_disksize = inline_size;
1625out:
1626	brelse(iloc.bh);
1627	return ret;
1628}
1629
1630struct buffer_head *ext4_find_inline_entry(struct inode *dir,
1631					struct ext4_filename *fname,
1632					struct ext4_dir_entry_2 **res_dir,
1633					int *has_inline_data)
1634{
1635	int ret;
1636	struct ext4_iloc iloc;
1637	void *inline_start;
1638	int inline_size;
1639
1640	if (ext4_get_inode_loc(dir, &iloc))
1641		return NULL;
1642
1643	down_read(&EXT4_I(dir)->xattr_sem);
1644	if (!ext4_has_inline_data(dir)) {
1645		*has_inline_data = 0;
1646		goto out;
1647	}
1648
1649	inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
1650						EXT4_INLINE_DOTDOT_SIZE;
1651	inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
1652	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
1653			      dir, fname, 0, res_dir);
1654	if (ret == 1)
1655		goto out_find;
1656	if (ret < 0)
1657		goto out;
1658
1659	if (ext4_get_inline_size(dir) == EXT4_MIN_INLINE_DATA_SIZE)
1660		goto out;
1661
1662	inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1663	inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE;
1664
1665	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
1666			      dir, fname, 0, res_dir);
1667	if (ret == 1)
1668		goto out_find;
1669
1670out:
1671	brelse(iloc.bh);
1672	iloc.bh = NULL;
1673out_find:
1674	up_read(&EXT4_I(dir)->xattr_sem);
1675	return iloc.bh;
1676}
1677
1678int ext4_delete_inline_entry(handle_t *handle,
1679			     struct inode *dir,
1680			     struct ext4_dir_entry_2 *de_del,
1681			     struct buffer_head *bh,
1682			     int *has_inline_data)
1683{
1684	int err, inline_size, no_expand;
1685	struct ext4_iloc iloc;
1686	void *inline_start;
1687
1688	err = ext4_get_inode_loc(dir, &iloc);
1689	if (err)
1690		return err;
1691
1692	ext4_write_lock_xattr(dir, &no_expand);
1693	if (!ext4_has_inline_data(dir)) {
1694		*has_inline_data = 0;
1695		goto out;
1696	}
1697
1698	if ((void *)de_del - ((void *)ext4_raw_inode(&iloc)->i_block) <
1699		EXT4_MIN_INLINE_DATA_SIZE) {
1700		inline_start = (void *)ext4_raw_inode(&iloc)->i_block +
1701					EXT4_INLINE_DOTDOT_SIZE;
1702		inline_size = EXT4_MIN_INLINE_DATA_SIZE -
1703				EXT4_INLINE_DOTDOT_SIZE;
1704	} else {
1705		inline_start = ext4_get_inline_xattr_pos(dir, &iloc);
1706		inline_size = ext4_get_inline_size(dir) -
1707				EXT4_MIN_INLINE_DATA_SIZE;
1708	}
1709
1710	BUFFER_TRACE(bh, "get_write_access");
1711	err = ext4_journal_get_write_access(handle, bh);
1712	if (err)
1713		goto out;
1714
1715	err = ext4_generic_delete_entry(dir, de_del, bh,
1716					inline_start, inline_size, 0);
1717	if (err)
1718		goto out;
1719
1720	ext4_show_inline_dir(dir, iloc.bh, inline_start, inline_size);
1721out:
1722	ext4_write_unlock_xattr(dir, &no_expand);
1723	if (likely(err == 0))
1724		err = ext4_mark_inode_dirty(handle, dir);
1725	brelse(iloc.bh);
1726	if (err != -ENOENT)
1727		ext4_std_error(dir->i_sb, err);
1728	return err;
1729}
1730
1731/*
1732 * Get the inline dentry at offset.
1733 */
1734static inline struct ext4_dir_entry_2 *
1735ext4_get_inline_entry(struct inode *inode,
1736		      struct ext4_iloc *iloc,
1737		      unsigned int offset,
1738		      void **inline_start,
1739		      int *inline_size)
1740{
1741	void *inline_pos;
1742
1743	BUG_ON(offset > ext4_get_inline_size(inode));
1744
1745	if (offset < EXT4_MIN_INLINE_DATA_SIZE) {
1746		inline_pos = (void *)ext4_raw_inode(iloc)->i_block;
1747		*inline_size = EXT4_MIN_INLINE_DATA_SIZE;
1748	} else {
1749		inline_pos = ext4_get_inline_xattr_pos(inode, iloc);
1750		offset -= EXT4_MIN_INLINE_DATA_SIZE;
1751		*inline_size = ext4_get_inline_size(inode) -
1752				EXT4_MIN_INLINE_DATA_SIZE;
1753	}
1754
1755	if (inline_start)
1756		*inline_start = inline_pos;
1757	return (struct ext4_dir_entry_2 *)(inline_pos + offset);
1758}
1759
1760bool empty_inline_dir(struct inode *dir, int *has_inline_data)
1761{
1762	int err, inline_size;
1763	struct ext4_iloc iloc;
1764	size_t inline_len;
1765	void *inline_pos;
1766	unsigned int offset;
1767	struct ext4_dir_entry_2 *de;
1768	bool ret = true;
1769
1770	err = ext4_get_inode_loc(dir, &iloc);
1771	if (err) {
1772		EXT4_ERROR_INODE_ERR(dir, -err,
1773				     "error %d getting inode %lu block",
1774				     err, dir->i_ino);
1775		return true;
1776	}
1777
1778	down_read(&EXT4_I(dir)->xattr_sem);
1779	if (!ext4_has_inline_data(dir)) {
1780		*has_inline_data = 0;
1781		goto out;
1782	}
1783
1784	de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
1785	if (!le32_to_cpu(de->inode)) {
1786		ext4_warning(dir->i_sb,
1787			     "bad inline directory (dir #%lu) - no `..'",
1788			     dir->i_ino);
1789		ret = true;
1790		goto out;
1791	}
1792
1793	inline_len = ext4_get_inline_size(dir);
1794	offset = EXT4_INLINE_DOTDOT_SIZE;
1795	while (offset < inline_len) {
1796		de = ext4_get_inline_entry(dir, &iloc, offset,
1797					   &inline_pos, &inline_size);
1798		if (ext4_check_dir_entry(dir, NULL, de,
1799					 iloc.bh, inline_pos,
1800					 inline_size, offset)) {
1801			ext4_warning(dir->i_sb,
1802				     "bad inline directory (dir #%lu) - "
1803				     "inode %u, rec_len %u, name_len %d"
1804				     "inline size %d",
1805				     dir->i_ino, le32_to_cpu(de->inode),
1806				     le16_to_cpu(de->rec_len), de->name_len,
1807				     inline_size);
1808			ret = true;
1809			goto out;
1810		}
1811		if (le32_to_cpu(de->inode)) {
1812			ret = false;
1813			goto out;
1814		}
1815		offset += ext4_rec_len_from_disk(de->rec_len, inline_size);
1816	}
1817
1818out:
1819	up_read(&EXT4_I(dir)->xattr_sem);
1820	brelse(iloc.bh);
1821	return ret;
1822}
1823
1824int ext4_destroy_inline_data(handle_t *handle, struct inode *inode)
1825{
1826	int ret, no_expand;
1827
1828	ext4_write_lock_xattr(inode, &no_expand);
1829	ret = ext4_destroy_inline_data_nolock(handle, inode);
1830	ext4_write_unlock_xattr(inode, &no_expand);
1831
1832	return ret;
1833}
1834
1835int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap)
1836{
1837	__u64 addr;
1838	int error = -EAGAIN;
1839	struct ext4_iloc iloc;
1840
1841	down_read(&EXT4_I(inode)->xattr_sem);
1842	if (!ext4_has_inline_data(inode))
1843		goto out;
1844
1845	error = ext4_get_inode_loc(inode, &iloc);
1846	if (error)
1847		goto out;
1848
1849	addr = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits;
1850	addr += (char *)ext4_raw_inode(&iloc) - iloc.bh->b_data;
1851	addr += offsetof(struct ext4_inode, i_block);
1852
1853	brelse(iloc.bh);
1854
1855	iomap->addr = addr;
1856	iomap->offset = 0;
1857	iomap->length = min_t(loff_t, ext4_get_inline_size(inode),
1858			      i_size_read(inode));
1859	iomap->type = IOMAP_INLINE;
1860	iomap->flags = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1861
 
 
 
 
 
 
 
 
1862out:
1863	up_read(&EXT4_I(inode)->xattr_sem);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1864	return error;
1865}
1866
1867int ext4_inline_data_truncate(struct inode *inode, int *has_inline)
1868{
1869	handle_t *handle;
1870	int inline_size, value_len, needed_blocks, no_expand, err = 0;
1871	size_t i_size;
1872	void *value = NULL;
1873	struct ext4_xattr_ibody_find is = {
1874		.s = { .not_found = -ENODATA, },
1875	};
1876	struct ext4_xattr_info i = {
1877		.name_index = EXT4_XATTR_INDEX_SYSTEM,
1878		.name = EXT4_XATTR_SYSTEM_DATA,
1879	};
1880
1881
1882	needed_blocks = ext4_writepage_trans_blocks(inode);
1883	handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
1884	if (IS_ERR(handle))
1885		return PTR_ERR(handle);
1886
1887	ext4_write_lock_xattr(inode, &no_expand);
1888	if (!ext4_has_inline_data(inode)) {
1889		ext4_write_unlock_xattr(inode, &no_expand);
1890		*has_inline = 0;
1891		ext4_journal_stop(handle);
1892		return 0;
1893	}
1894
1895	if ((err = ext4_orphan_add(handle, inode)) != 0)
1896		goto out;
1897
1898	if ((err = ext4_get_inode_loc(inode, &is.iloc)) != 0)
1899		goto out;
1900
1901	down_write(&EXT4_I(inode)->i_data_sem);
1902	i_size = inode->i_size;
1903	inline_size = ext4_get_inline_size(inode);
1904	EXT4_I(inode)->i_disksize = i_size;
1905
1906	if (i_size < inline_size) {
1907		/* Clear the content in the xattr space. */
1908		if (inline_size > EXT4_MIN_INLINE_DATA_SIZE) {
1909			if ((err = ext4_xattr_ibody_find(inode, &i, &is)) != 0)
1910				goto out_error;
1911
1912			BUG_ON(is.s.not_found);
1913
1914			value_len = le32_to_cpu(is.s.here->e_value_size);
1915			value = kmalloc(value_len, GFP_NOFS);
1916			if (!value) {
1917				err = -ENOMEM;
1918				goto out_error;
1919			}
1920
1921			err = ext4_xattr_ibody_get(inode, i.name_index,
1922						   i.name, value, value_len);
1923			if (err <= 0)
1924				goto out_error;
1925
1926			i.value = value;
1927			i.value_len = i_size > EXT4_MIN_INLINE_DATA_SIZE ?
1928					i_size - EXT4_MIN_INLINE_DATA_SIZE : 0;
1929			err = ext4_xattr_ibody_set(handle, inode, &i, &is);
 
1930			if (err)
1931				goto out_error;
1932		}
1933
1934		/* Clear the content within i_blocks. */
1935		if (i_size < EXT4_MIN_INLINE_DATA_SIZE) {
1936			void *p = (void *) ext4_raw_inode(&is.iloc)->i_block;
1937			memset(p + i_size, 0,
1938			       EXT4_MIN_INLINE_DATA_SIZE - i_size);
1939		}
1940
1941		EXT4_I(inode)->i_inline_size = i_size <
1942					EXT4_MIN_INLINE_DATA_SIZE ?
1943					EXT4_MIN_INLINE_DATA_SIZE : i_size;
1944	}
1945
1946out_error:
1947	up_write(&EXT4_I(inode)->i_data_sem);
1948out:
1949	brelse(is.iloc.bh);
1950	ext4_write_unlock_xattr(inode, &no_expand);
1951	kfree(value);
1952	if (inode->i_nlink)
1953		ext4_orphan_del(handle, inode);
1954
1955	if (err == 0) {
1956		inode->i_mtime = inode->i_ctime = current_time(inode);
1957		err = ext4_mark_inode_dirty(handle, inode);
1958		if (IS_SYNC(inode))
1959			ext4_handle_sync(handle);
1960	}
1961	ext4_journal_stop(handle);
1962	return err;
1963}
1964
1965int ext4_convert_inline_data(struct inode *inode)
1966{
1967	int error, needed_blocks, no_expand;
1968	handle_t *handle;
1969	struct ext4_iloc iloc;
1970
1971	if (!ext4_has_inline_data(inode)) {
1972		ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1973		return 0;
1974	}
1975
1976	needed_blocks = ext4_writepage_trans_blocks(inode);
1977
1978	iloc.bh = NULL;
1979	error = ext4_get_inode_loc(inode, &iloc);
1980	if (error)
1981		return error;
1982
1983	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1984	if (IS_ERR(handle)) {
1985		error = PTR_ERR(handle);
1986		goto out_free;
1987	}
1988
1989	ext4_write_lock_xattr(inode, &no_expand);
1990	if (ext4_has_inline_data(inode))
1991		error = ext4_convert_inline_data_nolock(handle, inode, &iloc);
1992	ext4_write_unlock_xattr(inode, &no_expand);
1993	ext4_journal_stop(handle);
1994out_free:
1995	brelse(iloc.bh);
1996	return error;
1997}