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