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