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