PageRenderTime 9ms CodeModel.GetById 4ms app.highlight 86ms RepoModel.GetById 2ms app.codeStats 0ms

/fs/ext4/xattr.c

https://bitbucket.org/zarboz/ville-upstream-test-branch
C | 1608 lines | 1259 code | 143 blank | 206 comment | 275 complexity | 7614be387b4fc15f2d6c054af5d7adc1 MD5 | raw file
   1/*
   2 * linux/fs/ext4/xattr.c
   3 *
   4 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
   5 *
   6 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
   7 * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
   8 * Extended attributes for symlinks and special files added per
   9 *  suggestion of Luka Renko <luka.renko@hermes.si>.
  10 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
  11 *  Red Hat Inc.
  12 * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
  13 *  and Andreas Gruenbacher <agruen@suse.de>.
  14 */
  15
  16/*
  17 * Extended attributes are stored directly in inodes (on file systems with
  18 * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
  19 * field contains the block number if an inode uses an additional block. All
  20 * attributes must fit in the inode and one additional block. Blocks that
  21 * contain the identical set of attributes may be shared among several inodes.
  22 * Identical blocks are detected by keeping a cache of blocks that have
  23 * recently been accessed.
  24 *
  25 * The attributes in inodes and on blocks have a different header; the entries
  26 * are stored in the same format:
  27 *
  28 *   +------------------+
  29 *   | header           |
  30 *   | entry 1          | |
  31 *   | entry 2          | | growing downwards
  32 *   | entry 3          | v
  33 *   | four null bytes  |
  34 *   | . . .            |
  35 *   | value 1          | ^
  36 *   | value 3          | | growing upwards
  37 *   | value 2          | |
  38 *   +------------------+
  39 *
  40 * The header is followed by multiple entry descriptors. In disk blocks, the
  41 * entry descriptors are kept sorted. In inodes, they are unsorted. The
  42 * attribute values are aligned to the end of the block in no specific order.
  43 *
  44 * Locking strategy
  45 * ----------------
  46 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
  47 * EA blocks are only changed if they are exclusive to an inode, so
  48 * holding xattr_sem also means that nothing but the EA block's reference
  49 * count can change. Multiple writers to the same block are synchronized
  50 * by the buffer lock.
  51 */
  52
  53#include <linux/init.h>
  54#include <linux/fs.h>
  55#include <linux/slab.h>
  56#include <linux/mbcache.h>
  57#include <linux/quotaops.h>
  58#include <linux/rwsem.h>
  59#include "ext4_jbd2.h"
  60#include "ext4.h"
  61#include "xattr.h"
  62#include "acl.h"
  63
  64#define BHDR(bh) ((struct ext4_xattr_header *)((bh)->b_data))
  65#define ENTRY(ptr) ((struct ext4_xattr_entry *)(ptr))
  66#define BFIRST(bh) ENTRY(BHDR(bh)+1)
  67#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
  68
  69#ifdef EXT4_XATTR_DEBUG
  70# define ea_idebug(inode, f...) do { \
  71		printk(KERN_DEBUG "inode %s:%lu: ", \
  72			inode->i_sb->s_id, inode->i_ino); \
  73		printk(f); \
  74		printk("\n"); \
  75	} while (0)
  76# define ea_bdebug(bh, f...) do { \
  77		char b[BDEVNAME_SIZE]; \
  78		printk(KERN_DEBUG "block %s:%lu: ", \
  79			bdevname(bh->b_bdev, b), \
  80			(unsigned long) bh->b_blocknr); \
  81		printk(f); \
  82		printk("\n"); \
  83	} while (0)
  84#else
  85# define ea_idebug(f...)
  86# define ea_bdebug(f...)
  87#endif
  88
  89static void ext4_xattr_cache_insert(struct buffer_head *);
  90static struct buffer_head *ext4_xattr_cache_find(struct inode *,
  91						 struct ext4_xattr_header *,
  92						 struct mb_cache_entry **);
  93static void ext4_xattr_rehash(struct ext4_xattr_header *,
  94			      struct ext4_xattr_entry *);
  95static int ext4_xattr_list(struct dentry *dentry, char *buffer,
  96			   size_t buffer_size);
  97
  98static struct mb_cache *ext4_xattr_cache;
  99
 100static const struct xattr_handler *ext4_xattr_handler_map[] = {
 101	[EXT4_XATTR_INDEX_USER]		     = &ext4_xattr_user_handler,
 102#ifdef CONFIG_EXT4_FS_POSIX_ACL
 103	[EXT4_XATTR_INDEX_POSIX_ACL_ACCESS]  = &ext4_xattr_acl_access_handler,
 104	[EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext4_xattr_acl_default_handler,
 105#endif
 106	[EXT4_XATTR_INDEX_TRUSTED]	     = &ext4_xattr_trusted_handler,
 107#ifdef CONFIG_EXT4_FS_SECURITY
 108	[EXT4_XATTR_INDEX_SECURITY]	     = &ext4_xattr_security_handler,
 109#endif
 110};
 111
 112const struct xattr_handler *ext4_xattr_handlers[] = {
 113	&ext4_xattr_user_handler,
 114	&ext4_xattr_trusted_handler,
 115#ifdef CONFIG_EXT4_FS_POSIX_ACL
 116	&ext4_xattr_acl_access_handler,
 117	&ext4_xattr_acl_default_handler,
 118#endif
 119#ifdef CONFIG_EXT4_FS_SECURITY
 120	&ext4_xattr_security_handler,
 121#endif
 122	NULL
 123};
 124
 125static inline const struct xattr_handler *
 126ext4_xattr_handler(int name_index)
 127{
 128	const struct xattr_handler *handler = NULL;
 129
 130	if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
 131		handler = ext4_xattr_handler_map[name_index];
 132	return handler;
 133}
 134
 135/*
 136 * Inode operation listxattr()
 137 *
 138 * dentry->d_inode->i_mutex: don't care
 139 */
 140ssize_t
 141ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
 142{
 143	return ext4_xattr_list(dentry, buffer, size);
 144}
 145
 146static int
 147ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end)
 148{
 149	while (!IS_LAST_ENTRY(entry)) {
 150		struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(entry);
 151		if ((void *)next >= end)
 152			return -EIO;
 153		entry = next;
 154	}
 155	return 0;
 156}
 157
 158static inline int
 159ext4_xattr_check_block(struct buffer_head *bh)
 160{
 161	int error;
 162
 163	if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
 164	    BHDR(bh)->h_blocks != cpu_to_le32(1))
 165		return -EIO;
 166	error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size);
 167	return error;
 168}
 169
 170static inline int
 171ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
 172{
 173	size_t value_size = le32_to_cpu(entry->e_value_size);
 174
 175	if (entry->e_value_block != 0 || value_size > size ||
 176	    le16_to_cpu(entry->e_value_offs) + value_size > size)
 177		return -EIO;
 178	return 0;
 179}
 180
 181static int
 182ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
 183		      const char *name, size_t size, int sorted)
 184{
 185	struct ext4_xattr_entry *entry;
 186	size_t name_len;
 187	int cmp = 1;
 188
 189	if (name == NULL)
 190		return -EINVAL;
 191	name_len = strlen(name);
 192	entry = *pentry;
 193	for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
 194		cmp = name_index - entry->e_name_index;
 195		if (!cmp)
 196			cmp = name_len - entry->e_name_len;
 197		if (!cmp)
 198			cmp = memcmp(name, entry->e_name, name_len);
 199		if (cmp <= 0 && (sorted || cmp == 0))
 200			break;
 201	}
 202	*pentry = entry;
 203	if (!cmp && ext4_xattr_check_entry(entry, size))
 204			return -EIO;
 205	return cmp ? -ENODATA : 0;
 206}
 207
 208static int
 209ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
 210		     void *buffer, size_t buffer_size)
 211{
 212	struct buffer_head *bh = NULL;
 213	struct ext4_xattr_entry *entry;
 214	size_t size;
 215	int error;
 216
 217	ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
 218		  name_index, name, buffer, (long)buffer_size);
 219
 220	error = -ENODATA;
 221	if (!EXT4_I(inode)->i_file_acl)
 222		goto cleanup;
 223	ea_idebug(inode, "reading block %u", EXT4_I(inode)->i_file_acl);
 224	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
 225	if (!bh)
 226		goto cleanup;
 227	ea_bdebug(bh, "b_count=%d, refcount=%d",
 228		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
 229	if (ext4_xattr_check_block(bh)) {
 230bad_block:
 231		EXT4_ERROR_INODE(inode, "bad block %llu",
 232				 EXT4_I(inode)->i_file_acl);
 233		error = -EIO;
 234		goto cleanup;
 235	}
 236	ext4_xattr_cache_insert(bh);
 237	entry = BFIRST(bh);
 238	error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
 239	if (error == -EIO)
 240		goto bad_block;
 241	if (error)
 242		goto cleanup;
 243	size = le32_to_cpu(entry->e_value_size);
 244	if (buffer) {
 245		error = -ERANGE;
 246		if (size > buffer_size)
 247			goto cleanup;
 248		memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 249		       size);
 250	}
 251	error = size;
 252
 253cleanup:
 254	brelse(bh);
 255	return error;
 256}
 257
 258static int
 259ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
 260		     void *buffer, size_t buffer_size)
 261{
 262	struct ext4_xattr_ibody_header *header;
 263	struct ext4_xattr_entry *entry;
 264	struct ext4_inode *raw_inode;
 265	struct ext4_iloc iloc;
 266	size_t size;
 267	void *end;
 268	int error;
 269
 270	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
 271		return -ENODATA;
 272	error = ext4_get_inode_loc(inode, &iloc);
 273	if (error)
 274		return error;
 275	raw_inode = ext4_raw_inode(&iloc);
 276	header = IHDR(inode, raw_inode);
 277	entry = IFIRST(header);
 278	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
 279	error = ext4_xattr_check_names(entry, end);
 280	if (error)
 281		goto cleanup;
 282	error = ext4_xattr_find_entry(&entry, name_index, name,
 283				      end - (void *)entry, 0);
 284	if (error)
 285		goto cleanup;
 286	size = le32_to_cpu(entry->e_value_size);
 287	if (buffer) {
 288		error = -ERANGE;
 289		if (size > buffer_size)
 290			goto cleanup;
 291		memcpy(buffer, (void *)IFIRST(header) +
 292		       le16_to_cpu(entry->e_value_offs), size);
 293	}
 294	error = size;
 295
 296cleanup:
 297	brelse(iloc.bh);
 298	return error;
 299}
 300
 301/*
 302 * ext4_xattr_get()
 303 *
 304 * Copy an extended attribute into the buffer
 305 * provided, or compute the buffer size required.
 306 * Buffer is NULL to compute the size of the buffer required.
 307 *
 308 * Returns a negative error number on failure, or the number of bytes
 309 * used / required on success.
 310 */
 311int
 312ext4_xattr_get(struct inode *inode, int name_index, const char *name,
 313	       void *buffer, size_t buffer_size)
 314{
 315	int error;
 316
 317	down_read(&EXT4_I(inode)->xattr_sem);
 318	error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
 319				     buffer_size);
 320	if (error == -ENODATA)
 321		error = ext4_xattr_block_get(inode, name_index, name, buffer,
 322					     buffer_size);
 323	up_read(&EXT4_I(inode)->xattr_sem);
 324	return error;
 325}
 326
 327static int
 328ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
 329			char *buffer, size_t buffer_size)
 330{
 331	size_t rest = buffer_size;
 332
 333	for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
 334		const struct xattr_handler *handler =
 335			ext4_xattr_handler(entry->e_name_index);
 336
 337		if (handler) {
 338			size_t size = handler->list(dentry, buffer, rest,
 339						    entry->e_name,
 340						    entry->e_name_len,
 341						    handler->flags);
 342			if (buffer) {
 343				if (size > rest)
 344					return -ERANGE;
 345				buffer += size;
 346			}
 347			rest -= size;
 348		}
 349	}
 350	return buffer_size - rest;
 351}
 352
 353static int
 354ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 355{
 356	struct inode *inode = dentry->d_inode;
 357	struct buffer_head *bh = NULL;
 358	int error;
 359
 360	ea_idebug(inode, "buffer=%p, buffer_size=%ld",
 361		  buffer, (long)buffer_size);
 362
 363	error = 0;
 364	if (!EXT4_I(inode)->i_file_acl)
 365		goto cleanup;
 366	ea_idebug(inode, "reading block %u", EXT4_I(inode)->i_file_acl);
 367	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
 368	error = -EIO;
 369	if (!bh)
 370		goto cleanup;
 371	ea_bdebug(bh, "b_count=%d, refcount=%d",
 372		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
 373	if (ext4_xattr_check_block(bh)) {
 374		EXT4_ERROR_INODE(inode, "bad block %llu",
 375				 EXT4_I(inode)->i_file_acl);
 376		error = -EIO;
 377		goto cleanup;
 378	}
 379	ext4_xattr_cache_insert(bh);
 380	error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
 381
 382cleanup:
 383	brelse(bh);
 384
 385	return error;
 386}
 387
 388static int
 389ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 390{
 391	struct inode *inode = dentry->d_inode;
 392	struct ext4_xattr_ibody_header *header;
 393	struct ext4_inode *raw_inode;
 394	struct ext4_iloc iloc;
 395	void *end;
 396	int error;
 397
 398	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
 399		return 0;
 400	error = ext4_get_inode_loc(inode, &iloc);
 401	if (error)
 402		return error;
 403	raw_inode = ext4_raw_inode(&iloc);
 404	header = IHDR(inode, raw_inode);
 405	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
 406	error = ext4_xattr_check_names(IFIRST(header), end);
 407	if (error)
 408		goto cleanup;
 409	error = ext4_xattr_list_entries(dentry, IFIRST(header),
 410					buffer, buffer_size);
 411
 412cleanup:
 413	brelse(iloc.bh);
 414	return error;
 415}
 416
 417/*
 418 * ext4_xattr_list()
 419 *
 420 * Copy a list of attribute names into the buffer
 421 * provided, or compute the buffer size required.
 422 * Buffer is NULL to compute the size of the buffer required.
 423 *
 424 * Returns a negative error number on failure, or the number of bytes
 425 * used / required on success.
 426 */
 427static int
 428ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 429{
 430	int ret, ret2;
 431
 432	down_read(&EXT4_I(dentry->d_inode)->xattr_sem);
 433	ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
 434	if (ret < 0)
 435		goto errout;
 436	if (buffer) {
 437		buffer += ret;
 438		buffer_size -= ret;
 439	}
 440	ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
 441	if (ret < 0)
 442		goto errout;
 443	ret += ret2;
 444errout:
 445	up_read(&EXT4_I(dentry->d_inode)->xattr_sem);
 446	return ret;
 447}
 448
 449/*
 450 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
 451 * not set, set it.
 452 */
 453static void ext4_xattr_update_super_block(handle_t *handle,
 454					  struct super_block *sb)
 455{
 456	if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR))
 457		return;
 458
 459	if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
 460		EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR);
 461		ext4_handle_dirty_super(handle, sb);
 462	}
 463}
 464
 465/*
 466 * Release the xattr block BH: If the reference count is > 1, decrement
 467 * it; otherwise free the block.
 468 */
 469static void
 470ext4_xattr_release_block(handle_t *handle, struct inode *inode,
 471			 struct buffer_head *bh)
 472{
 473	struct mb_cache_entry *ce = NULL;
 474	int error = 0;
 475
 476	ce = mb_cache_entry_get(ext4_xattr_cache, bh->b_bdev, bh->b_blocknr);
 477	error = ext4_journal_get_write_access(handle, bh);
 478	if (error)
 479		goto out;
 480
 481	lock_buffer(bh);
 482	if (BHDR(bh)->h_refcount == cpu_to_le32(1)) {
 483		ea_bdebug(bh, "refcount now=0; freeing");
 484		if (ce)
 485			mb_cache_entry_free(ce);
 486		get_bh(bh);
 487		ext4_free_blocks(handle, inode, bh, 0, 1,
 488				 EXT4_FREE_BLOCKS_METADATA |
 489				 EXT4_FREE_BLOCKS_FORGET);
 490		unlock_buffer(bh);
 491	} else {
 492		le32_add_cpu(&BHDR(bh)->h_refcount, -1);
 493		if (ce)
 494			mb_cache_entry_release(ce);
 495		unlock_buffer(bh);
 496		error = ext4_handle_dirty_metadata(handle, inode, bh);
 497		if (IS_SYNC(inode))
 498			ext4_handle_sync(handle);
 499		dquot_free_block(inode, 1);
 500		ea_bdebug(bh, "refcount now=%d; releasing",
 501			  le32_to_cpu(BHDR(bh)->h_refcount));
 502	}
 503out:
 504	ext4_std_error(inode->i_sb, error);
 505	return;
 506}
 507
 508/*
 509 * Find the available free space for EAs. This also returns the total number of
 510 * bytes used by EA entries.
 511 */
 512static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
 513				    size_t *min_offs, void *base, int *total)
 514{
 515	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 516		*total += EXT4_XATTR_LEN(last->e_name_len);
 517		if (!last->e_value_block && last->e_value_size) {
 518			size_t offs = le16_to_cpu(last->e_value_offs);
 519			if (offs < *min_offs)
 520				*min_offs = offs;
 521		}
 522	}
 523	return (*min_offs - ((void *)last - base) - sizeof(__u32));
 524}
 525
 526struct ext4_xattr_info {
 527	int name_index;
 528	const char *name;
 529	const void *value;
 530	size_t value_len;
 531};
 532
 533struct ext4_xattr_search {
 534	struct ext4_xattr_entry *first;
 535	void *base;
 536	void *end;
 537	struct ext4_xattr_entry *here;
 538	int not_found;
 539};
 540
 541static int
 542ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
 543{
 544	struct ext4_xattr_entry *last;
 545	size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
 546
 547	/* Compute min_offs and last. */
 548	last = s->first;
 549	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 550		if (!last->e_value_block && last->e_value_size) {
 551			size_t offs = le16_to_cpu(last->e_value_offs);
 552			if (offs < min_offs)
 553				min_offs = offs;
 554		}
 555	}
 556	free = min_offs - ((void *)last - s->base) - sizeof(__u32);
 557	if (!s->not_found) {
 558		if (!s->here->e_value_block && s->here->e_value_size) {
 559			size_t size = le32_to_cpu(s->here->e_value_size);
 560			free += EXT4_XATTR_SIZE(size);
 561		}
 562		free += EXT4_XATTR_LEN(name_len);
 563	}
 564	if (i->value) {
 565		if (free < EXT4_XATTR_SIZE(i->value_len) ||
 566		    free < EXT4_XATTR_LEN(name_len) +
 567			   EXT4_XATTR_SIZE(i->value_len))
 568			return -ENOSPC;
 569	}
 570
 571	if (i->value && s->not_found) {
 572		/* Insert the new name. */
 573		size_t size = EXT4_XATTR_LEN(name_len);
 574		size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
 575		memmove((void *)s->here + size, s->here, rest);
 576		memset(s->here, 0, size);
 577		s->here->e_name_index = i->name_index;
 578		s->here->e_name_len = name_len;
 579		memcpy(s->here->e_name, i->name, name_len);
 580	} else {
 581		if (!s->here->e_value_block && s->here->e_value_size) {
 582			void *first_val = s->base + min_offs;
 583			size_t offs = le16_to_cpu(s->here->e_value_offs);
 584			void *val = s->base + offs;
 585			size_t size = EXT4_XATTR_SIZE(
 586				le32_to_cpu(s->here->e_value_size));
 587
 588			if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
 589				/* The old and the new value have the same
 590				   size. Just replace. */
 591				s->here->e_value_size =
 592					cpu_to_le32(i->value_len);
 593				memset(val + size - EXT4_XATTR_PAD, 0,
 594				       EXT4_XATTR_PAD); /* Clear pad bytes. */
 595				memcpy(val, i->value, i->value_len);
 596				return 0;
 597			}
 598
 599			/* Remove the old value. */
 600			memmove(first_val + size, first_val, val - first_val);
 601			memset(first_val, 0, size);
 602			s->here->e_value_size = 0;
 603			s->here->e_value_offs = 0;
 604			min_offs += size;
 605
 606			/* Adjust all value offsets. */
 607			last = s->first;
 608			while (!IS_LAST_ENTRY(last)) {
 609				size_t o = le16_to_cpu(last->e_value_offs);
 610				if (!last->e_value_block &&
 611				    last->e_value_size && o < offs)
 612					last->e_value_offs =
 613						cpu_to_le16(o + size);
 614				last = EXT4_XATTR_NEXT(last);
 615			}
 616		}
 617		if (!i->value) {
 618			/* Remove the old name. */
 619			size_t size = EXT4_XATTR_LEN(name_len);
 620			last = ENTRY((void *)last - size);
 621			memmove(s->here, (void *)s->here + size,
 622				(void *)last - (void *)s->here + sizeof(__u32));
 623			memset(last, 0, size);
 624		}
 625	}
 626
 627	if (i->value) {
 628		/* Insert the new value. */
 629		s->here->e_value_size = cpu_to_le32(i->value_len);
 630		if (i->value_len) {
 631			size_t size = EXT4_XATTR_SIZE(i->value_len);
 632			void *val = s->base + min_offs - size;
 633			s->here->e_value_offs = cpu_to_le16(min_offs - size);
 634			memset(val + size - EXT4_XATTR_PAD, 0,
 635			       EXT4_XATTR_PAD); /* Clear the pad bytes. */
 636			memcpy(val, i->value, i->value_len);
 637		}
 638	}
 639	return 0;
 640}
 641
 642struct ext4_xattr_block_find {
 643	struct ext4_xattr_search s;
 644	struct buffer_head *bh;
 645};
 646
 647static int
 648ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
 649		      struct ext4_xattr_block_find *bs)
 650{
 651	struct super_block *sb = inode->i_sb;
 652	int error;
 653
 654	ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
 655		  i->name_index, i->name, i->value, (long)i->value_len);
 656
 657	if (EXT4_I(inode)->i_file_acl) {
 658		/* The inode already has an extended attribute block. */
 659		bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
 660		error = -EIO;
 661		if (!bs->bh)
 662			goto cleanup;
 663		ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
 664			atomic_read(&(bs->bh->b_count)),
 665			le32_to_cpu(BHDR(bs->bh)->h_refcount));
 666		if (ext4_xattr_check_block(bs->bh)) {
 667			EXT4_ERROR_INODE(inode, "bad block %llu",
 668					 EXT4_I(inode)->i_file_acl);
 669			error = -EIO;
 670			goto cleanup;
 671		}
 672		/* Find the named attribute. */
 673		bs->s.base = BHDR(bs->bh);
 674		bs->s.first = BFIRST(bs->bh);
 675		bs->s.end = bs->bh->b_data + bs->bh->b_size;
 676		bs->s.here = bs->s.first;
 677		error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
 678					      i->name, bs->bh->b_size, 1);
 679		if (error && error != -ENODATA)
 680			goto cleanup;
 681		bs->s.not_found = error;
 682	}
 683	error = 0;
 684
 685cleanup:
 686	return error;
 687}
 688
 689static int
 690ext4_xattr_block_set(handle_t *handle, struct inode *inode,
 691		     struct ext4_xattr_info *i,
 692		     struct ext4_xattr_block_find *bs)
 693{
 694	struct super_block *sb = inode->i_sb;
 695	struct buffer_head *new_bh = NULL;
 696	struct ext4_xattr_search *s = &bs->s;
 697	struct mb_cache_entry *ce = NULL;
 698	int error = 0;
 699
 700#define header(x) ((struct ext4_xattr_header *)(x))
 701
 702	if (i->value && i->value_len > sb->s_blocksize)
 703		return -ENOSPC;
 704	if (s->base) {
 705		ce = mb_cache_entry_get(ext4_xattr_cache, bs->bh->b_bdev,
 706					bs->bh->b_blocknr);
 707		error = ext4_journal_get_write_access(handle, bs->bh);
 708		if (error)
 709			goto cleanup;
 710		lock_buffer(bs->bh);
 711
 712		if (header(s->base)->h_refcount == cpu_to_le32(1)) {
 713			if (ce) {
 714				mb_cache_entry_free(ce);
 715				ce = NULL;
 716			}
 717			ea_bdebug(bs->bh, "modifying in-place");
 718			error = ext4_xattr_set_entry(i, s);
 719			if (!error) {
 720				if (!IS_LAST_ENTRY(s->first))
 721					ext4_xattr_rehash(header(s->base),
 722							  s->here);
 723				ext4_xattr_cache_insert(bs->bh);
 724			}
 725			unlock_buffer(bs->bh);
 726			if (error == -EIO)
 727				goto bad_block;
 728			if (!error)
 729				error = ext4_handle_dirty_metadata(handle,
 730								   inode,
 731								   bs->bh);
 732			if (error)
 733				goto cleanup;
 734			goto inserted;
 735		} else {
 736			int offset = (char *)s->here - bs->bh->b_data;
 737
 738			unlock_buffer(bs->bh);
 739			ext4_handle_release_buffer(handle, bs->bh);
 740			if (ce) {
 741				mb_cache_entry_release(ce);
 742				ce = NULL;
 743			}
 744			ea_bdebug(bs->bh, "cloning");
 745			s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
 746			error = -ENOMEM;
 747			if (s->base == NULL)
 748				goto cleanup;
 749			memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
 750			s->first = ENTRY(header(s->base)+1);
 751			header(s->base)->h_refcount = cpu_to_le32(1);
 752			s->here = ENTRY(s->base + offset);
 753			s->end = s->base + bs->bh->b_size;
 754		}
 755	} else {
 756		/* Allocate a buffer where we construct the new block. */
 757		s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
 758		/* assert(header == s->base) */
 759		error = -ENOMEM;
 760		if (s->base == NULL)
 761			goto cleanup;
 762		header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
 763		header(s->base)->h_blocks = cpu_to_le32(1);
 764		header(s->base)->h_refcount = cpu_to_le32(1);
 765		s->first = ENTRY(header(s->base)+1);
 766		s->here = ENTRY(header(s->base)+1);
 767		s->end = s->base + sb->s_blocksize;
 768	}
 769
 770	error = ext4_xattr_set_entry(i, s);
 771	if (error == -EIO)
 772		goto bad_block;
 773	if (error)
 774		goto cleanup;
 775	if (!IS_LAST_ENTRY(s->first))
 776		ext4_xattr_rehash(header(s->base), s->here);
 777
 778inserted:
 779	if (!IS_LAST_ENTRY(s->first)) {
 780		new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
 781		if (new_bh) {
 782			/* We found an identical block in the cache. */
 783			if (new_bh == bs->bh)
 784				ea_bdebug(new_bh, "keeping");
 785			else {
 786				/* The old block is released after updating
 787				   the inode. */
 788				error = dquot_alloc_block(inode, 1);
 789				if (error)
 790					goto cleanup;
 791				error = ext4_journal_get_write_access(handle,
 792								      new_bh);
 793				if (error)
 794					goto cleanup_dquot;
 795				lock_buffer(new_bh);
 796				le32_add_cpu(&BHDR(new_bh)->h_refcount, 1);
 797				ea_bdebug(new_bh, "reusing; refcount now=%d",
 798					le32_to_cpu(BHDR(new_bh)->h_refcount));
 799				unlock_buffer(new_bh);
 800				error = ext4_handle_dirty_metadata(handle,
 801								   inode,
 802								   new_bh);
 803				if (error)
 804					goto cleanup_dquot;
 805			}
 806			mb_cache_entry_release(ce);
 807			ce = NULL;
 808		} else if (bs->bh && s->base == bs->bh->b_data) {
 809			/* We were modifying this block in-place. */
 810			ea_bdebug(bs->bh, "keeping this block");
 811			new_bh = bs->bh;
 812			get_bh(new_bh);
 813		} else {
 814			/* We need to allocate a new block */
 815			ext4_fsblk_t goal, block;
 816
 817			goal = ext4_group_first_block_no(sb,
 818						EXT4_I(inode)->i_block_group);
 819
 820			/* non-extent files can't have physical blocks past 2^32 */
 821			if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
 822				goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
 823
 824			/*
 825			 * take i_data_sem because we will test
 826			 * i_delalloc_reserved_flag in ext4_mb_new_blocks
 827			 */
 828			down_read((&EXT4_I(inode)->i_data_sem));
 829			block = ext4_new_meta_blocks(handle, inode, goal, 0,
 830						     NULL, &error);
 831			up_read((&EXT4_I(inode)->i_data_sem));
 832			if (error)
 833				goto cleanup;
 834
 835			if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
 836				BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
 837
 838			ea_idebug(inode, "creating block %d", block);
 839
 840			new_bh = sb_getblk(sb, block);
 841			if (!new_bh) {
 842getblk_failed:
 843				ext4_free_blocks(handle, inode, NULL, block, 1,
 844						 EXT4_FREE_BLOCKS_METADATA);
 845				error = -EIO;
 846				goto cleanup;
 847			}
 848			lock_buffer(new_bh);
 849			error = ext4_journal_get_create_access(handle, new_bh);
 850			if (error) {
 851				unlock_buffer(new_bh);
 852				goto getblk_failed;
 853			}
 854			memcpy(new_bh->b_data, s->base, new_bh->b_size);
 855			set_buffer_uptodate(new_bh);
 856			unlock_buffer(new_bh);
 857			ext4_xattr_cache_insert(new_bh);
 858			error = ext4_handle_dirty_metadata(handle,
 859							   inode, new_bh);
 860			if (error)
 861				goto cleanup;
 862		}
 863	}
 864
 865	/* Update the inode. */
 866	EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
 867
 868	/* Drop the previous xattr block. */
 869	if (bs->bh && bs->bh != new_bh)
 870		ext4_xattr_release_block(handle, inode, bs->bh);
 871	error = 0;
 872
 873cleanup:
 874	if (ce)
 875		mb_cache_entry_release(ce);
 876	brelse(new_bh);
 877	if (!(bs->bh && s->base == bs->bh->b_data))
 878		kfree(s->base);
 879
 880	return error;
 881
 882cleanup_dquot:
 883	dquot_free_block(inode, 1);
 884	goto cleanup;
 885
 886bad_block:
 887	EXT4_ERROR_INODE(inode, "bad block %llu",
 888			 EXT4_I(inode)->i_file_acl);
 889	goto cleanup;
 890
 891#undef header
 892}
 893
 894struct ext4_xattr_ibody_find {
 895	struct ext4_xattr_search s;
 896	struct ext4_iloc iloc;
 897};
 898
 899static int
 900ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
 901		      struct ext4_xattr_ibody_find *is)
 902{
 903	struct ext4_xattr_ibody_header *header;
 904	struct ext4_inode *raw_inode;
 905	int error;
 906
 907	if (EXT4_I(inode)->i_extra_isize == 0)
 908		return 0;
 909	raw_inode = ext4_raw_inode(&is->iloc);
 910	header = IHDR(inode, raw_inode);
 911	is->s.base = is->s.first = IFIRST(header);
 912	is->s.here = is->s.first;
 913	is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
 914	if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
 915		error = ext4_xattr_check_names(IFIRST(header), is->s.end);
 916		if (error)
 917			return error;
 918		/* Find the named attribute. */
 919		error = ext4_xattr_find_entry(&is->s.here, i->name_index,
 920					      i->name, is->s.end -
 921					      (void *)is->s.base, 0);
 922		if (error && error != -ENODATA)
 923			return error;
 924		is->s.not_found = error;
 925	}
 926	return 0;
 927}
 928
 929static int
 930ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
 931		     struct ext4_xattr_info *i,
 932		     struct ext4_xattr_ibody_find *is)
 933{
 934	struct ext4_xattr_ibody_header *header;
 935	struct ext4_xattr_search *s = &is->s;
 936	int error;
 937
 938	if (EXT4_I(inode)->i_extra_isize == 0)
 939		return -ENOSPC;
 940	error = ext4_xattr_set_entry(i, s);
 941	if (error)
 942		return error;
 943	header = IHDR(inode, ext4_raw_inode(&is->iloc));
 944	if (!IS_LAST_ENTRY(s->first)) {
 945		header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
 946		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
 947	} else {
 948		header->h_magic = cpu_to_le32(0);
 949		ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
 950	}
 951	return 0;
 952}
 953
 954/*
 955 * ext4_xattr_set_handle()
 956 *
 957 * Create, replace or remove an extended attribute for this inode.  Value
 958 * is NULL to remove an existing extended attribute, and non-NULL to
 959 * either replace an existing extended attribute, or create a new extended
 960 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
 961 * specify that an extended attribute must exist and must not exist
 962 * previous to the call, respectively.
 963 *
 964 * Returns 0, or a negative error number on failure.
 965 */
 966int
 967ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
 968		      const char *name, const void *value, size_t value_len,
 969		      int flags)
 970{
 971	struct ext4_xattr_info i = {
 972		.name_index = name_index,
 973		.name = name,
 974		.value = value,
 975		.value_len = value_len,
 976
 977	};
 978	struct ext4_xattr_ibody_find is = {
 979		.s = { .not_found = -ENODATA, },
 980	};
 981	struct ext4_xattr_block_find bs = {
 982		.s = { .not_found = -ENODATA, },
 983	};
 984	unsigned long no_expand;
 985	int error;
 986
 987	if (!name)
 988		return -EINVAL;
 989	if (strlen(name) > 255)
 990		return -ERANGE;
 991	down_write(&EXT4_I(inode)->xattr_sem);
 992	no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
 993	ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
 994
 995	error = ext4_reserve_inode_write(handle, inode, &is.iloc);
 996	if (error)
 997		goto cleanup;
 998
 999	if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
1000		struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
1001		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
1002		ext4_clear_inode_state(inode, EXT4_STATE_NEW);
1003	}
1004
1005	error = ext4_xattr_ibody_find(inode, &i, &is);
1006	if (error)
1007		goto cleanup;
1008	if (is.s.not_found)
1009		error = ext4_xattr_block_find(inode, &i, &bs);
1010	if (error)
1011		goto cleanup;
1012	if (is.s.not_found && bs.s.not_found) {
1013		error = -ENODATA;
1014		if (flags & XATTR_REPLACE)
1015			goto cleanup;
1016		error = 0;
1017		if (!value)
1018			goto cleanup;
1019	} else {
1020		error = -EEXIST;
1021		if (flags & XATTR_CREATE)
1022			goto cleanup;
1023	}
1024	if (!value) {
1025		if (!is.s.not_found)
1026			error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1027		else if (!bs.s.not_found)
1028			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1029	} else {
1030		error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1031		if (!error && !bs.s.not_found) {
1032			i.value = NULL;
1033			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1034		} else if (error == -ENOSPC) {
1035			if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
1036				error = ext4_xattr_block_find(inode, &i, &bs);
1037				if (error)
1038					goto cleanup;
1039			}
1040			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1041			if (error)
1042				goto cleanup;
1043			if (!is.s.not_found) {
1044				i.value = NULL;
1045				error = ext4_xattr_ibody_set(handle, inode, &i,
1046							     &is);
1047			}
1048		}
1049	}
1050	if (!error) {
1051		ext4_xattr_update_super_block(handle, inode->i_sb);
1052		inode->i_ctime = ext4_current_time(inode);
1053		if (!value)
1054			ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1055		error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
1056		/*
1057		 * The bh is consumed by ext4_mark_iloc_dirty, even with
1058		 * error != 0.
1059		 */
1060		is.iloc.bh = NULL;
1061		if (IS_SYNC(inode))
1062			ext4_handle_sync(handle);
1063	}
1064
1065cleanup:
1066	brelse(is.iloc.bh);
1067	brelse(bs.bh);
1068	if (no_expand == 0)
1069		ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1070	up_write(&EXT4_I(inode)->xattr_sem);
1071	return error;
1072}
1073
1074/*
1075 * ext4_xattr_set()
1076 *
1077 * Like ext4_xattr_set_handle, but start from an inode. This extended
1078 * attribute modification is a filesystem transaction by itself.
1079 *
1080 * Returns 0, or a negative error number on failure.
1081 */
1082int
1083ext4_xattr_set(struct inode *inode, int name_index, const char *name,
1084	       const void *value, size_t value_len, int flags)
1085{
1086	handle_t *handle;
1087	int error, retries = 0;
1088
1089retry:
1090	handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
1091	if (IS_ERR(handle)) {
1092		error = PTR_ERR(handle);
1093	} else {
1094		int error2;
1095
1096		error = ext4_xattr_set_handle(handle, inode, name_index, name,
1097					      value, value_len, flags);
1098		error2 = ext4_journal_stop(handle);
1099		if (error == -ENOSPC &&
1100		    ext4_should_retry_alloc(inode->i_sb, &retries))
1101			goto retry;
1102		if (error == 0)
1103			error = error2;
1104	}
1105
1106	return error;
1107}
1108
1109/*
1110 * Shift the EA entries in the inode to create space for the increased
1111 * i_extra_isize.
1112 */
1113static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
1114				     int value_offs_shift, void *to,
1115				     void *from, size_t n, int blocksize)
1116{
1117	struct ext4_xattr_entry *last = entry;
1118	int new_offs;
1119
1120	/* Adjust the value offsets of the entries */
1121	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1122		if (!last->e_value_block && last->e_value_size) {
1123			new_offs = le16_to_cpu(last->e_value_offs) +
1124							value_offs_shift;
1125			BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
1126				 > blocksize);
1127			last->e_value_offs = cpu_to_le16(new_offs);
1128		}
1129	}
1130	/* Shift the entries by n bytes */
1131	memmove(to, from, n);
1132}
1133
1134/*
1135 * Expand an inode by new_extra_isize bytes when EAs are present.
1136 * Returns 0 on success or negative error number on failure.
1137 */
1138int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
1139			       struct ext4_inode *raw_inode, handle_t *handle)
1140{
1141	struct ext4_xattr_ibody_header *header;
1142	struct ext4_xattr_entry *entry, *last, *first;
1143	struct buffer_head *bh = NULL;
1144	struct ext4_xattr_ibody_find *is = NULL;
1145	struct ext4_xattr_block_find *bs = NULL;
1146	char *buffer = NULL, *b_entry_name = NULL;
1147	size_t min_offs, free;
1148	int total_ino, total_blk;
1149	void *base, *start, *end;
1150	int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
1151	int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
1152
1153	down_write(&EXT4_I(inode)->xattr_sem);
1154retry:
1155	if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
1156		up_write(&EXT4_I(inode)->xattr_sem);
1157		return 0;
1158	}
1159
1160	header = IHDR(inode, raw_inode);
1161	entry = IFIRST(header);
1162
1163	/*
1164	 * Check if enough free space is available in the inode to shift the
1165	 * entries ahead by new_extra_isize.
1166	 */
1167
1168	base = start = entry;
1169	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1170	min_offs = end - base;
1171	last = entry;
1172	total_ino = sizeof(struct ext4_xattr_ibody_header);
1173
1174	free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
1175	if (free >= new_extra_isize) {
1176		entry = IFIRST(header);
1177		ext4_xattr_shift_entries(entry,	EXT4_I(inode)->i_extra_isize
1178				- new_extra_isize, (void *)raw_inode +
1179				EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
1180				(void *)header, total_ino,
1181				inode->i_sb->s_blocksize);
1182		EXT4_I(inode)->i_extra_isize = new_extra_isize;
1183		error = 0;
1184		goto cleanup;
1185	}
1186
1187	/*
1188	 * Enough free space isn't available in the inode, check if
1189	 * EA block can hold new_extra_isize bytes.
1190	 */
1191	if (EXT4_I(inode)->i_file_acl) {
1192		bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1193		error = -EIO;
1194		if (!bh)
1195			goto cleanup;
1196		if (ext4_xattr_check_block(bh)) {
1197			EXT4_ERROR_INODE(inode, "bad block %llu",
1198					 EXT4_I(inode)->i_file_acl);
1199			error = -EIO;
1200			goto cleanup;
1201		}
1202		base = BHDR(bh);
1203		first = BFIRST(bh);
1204		end = bh->b_data + bh->b_size;
1205		min_offs = end - base;
1206		free = ext4_xattr_free_space(first, &min_offs, base,
1207					     &total_blk);
1208		if (free < new_extra_isize) {
1209			if (!tried_min_extra_isize && s_min_extra_isize) {
1210				tried_min_extra_isize++;
1211				new_extra_isize = s_min_extra_isize;
1212				brelse(bh);
1213				goto retry;
1214			}
1215			error = -1;
1216			goto cleanup;
1217		}
1218	} else {
1219		free = inode->i_sb->s_blocksize;
1220	}
1221
1222	while (new_extra_isize > 0) {
1223		size_t offs, size, entry_size;
1224		struct ext4_xattr_entry *small_entry = NULL;
1225		struct ext4_xattr_info i = {
1226			.value = NULL,
1227			.value_len = 0,
1228		};
1229		unsigned int total_size;  /* EA entry size + value size */
1230		unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
1231		unsigned int min_total_size = ~0U;
1232
1233		is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
1234		bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
1235		if (!is || !bs) {
1236			error = -ENOMEM;
1237			goto cleanup;
1238		}
1239
1240		is->s.not_found = -ENODATA;
1241		bs->s.not_found = -ENODATA;
1242		is->iloc.bh = NULL;
1243		bs->bh = NULL;
1244
1245		last = IFIRST(header);
1246		/* Find the entry best suited to be pushed into EA block */
1247		entry = NULL;
1248		for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
1249			total_size =
1250			EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
1251					EXT4_XATTR_LEN(last->e_name_len);
1252			if (total_size <= free && total_size < min_total_size) {
1253				if (total_size < new_extra_isize) {
1254					small_entry = last;
1255				} else {
1256					entry = last;
1257					min_total_size = total_size;
1258				}
1259			}
1260		}
1261
1262		if (entry == NULL) {
1263			if (small_entry) {
1264				entry = small_entry;
1265			} else {
1266				if (!tried_min_extra_isize &&
1267				    s_min_extra_isize) {
1268					tried_min_extra_isize++;
1269					new_extra_isize = s_min_extra_isize;
1270					goto retry;
1271				}
1272				error = -1;
1273				goto cleanup;
1274			}
1275		}
1276		offs = le16_to_cpu(entry->e_value_offs);
1277		size = le32_to_cpu(entry->e_value_size);
1278		entry_size = EXT4_XATTR_LEN(entry->e_name_len);
1279		i.name_index = entry->e_name_index,
1280		buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
1281		b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
1282		if (!buffer || !b_entry_name) {
1283			error = -ENOMEM;
1284			goto cleanup;
1285		}
1286		/* Save the entry name and the entry value */
1287		memcpy(buffer, (void *)IFIRST(header) + offs,
1288		       EXT4_XATTR_SIZE(size));
1289		memcpy(b_entry_name, entry->e_name, entry->e_name_len);
1290		b_entry_name[entry->e_name_len] = '\0';
1291		i.name = b_entry_name;
1292
1293		error = ext4_get_inode_loc(inode, &is->iloc);
1294		if (error)
1295			goto cleanup;
1296
1297		error = ext4_xattr_ibody_find(inode, &i, is);
1298		if (error)
1299			goto cleanup;
1300
1301		/* Remove the chosen entry from the inode */
1302		error = ext4_xattr_ibody_set(handle, inode, &i, is);
1303		if (error)
1304			goto cleanup;
1305
1306		entry = IFIRST(header);
1307		if (entry_size + EXT4_XATTR_SIZE(size) >= new_extra_isize)
1308			shift_bytes = new_extra_isize;
1309		else
1310			shift_bytes = entry_size + size;
1311		/* Adjust the offsets and shift the remaining entries ahead */
1312		ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
1313			shift_bytes, (void *)raw_inode +
1314			EXT4_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
1315			(void *)header, total_ino - entry_size,
1316			inode->i_sb->s_blocksize);
1317
1318		extra_isize += shift_bytes;
1319		new_extra_isize -= shift_bytes;
1320		EXT4_I(inode)->i_extra_isize = extra_isize;
1321
1322		i.name = b_entry_name;
1323		i.value = buffer;
1324		i.value_len = size;
1325		error = ext4_xattr_block_find(inode, &i, bs);
1326		if (error)
1327			goto cleanup;
1328
1329		/* Add entry which was removed from the inode into the block */
1330		error = ext4_xattr_block_set(handle, inode, &i, bs);
1331		if (error)
1332			goto cleanup;
1333		kfree(b_entry_name);
1334		kfree(buffer);
1335		b_entry_name = NULL;
1336		buffer = NULL;
1337		brelse(is->iloc.bh);
1338		kfree(is);
1339		kfree(bs);
1340	}
1341	brelse(bh);
1342	up_write(&EXT4_I(inode)->xattr_sem);
1343	return 0;
1344
1345cleanup:
1346	kfree(b_entry_name);
1347	kfree(buffer);
1348	if (is)
1349		brelse(is->iloc.bh);
1350	kfree(is);
1351	kfree(bs);
1352	brelse(bh);
1353	up_write(&EXT4_I(inode)->xattr_sem);
1354	return error;
1355}
1356
1357
1358
1359/*
1360 * ext4_xattr_delete_inode()
1361 *
1362 * Free extended attribute resources associated with this inode. This
1363 * is called immediately before an inode is freed. We have exclusive
1364 * access to the inode.
1365 */
1366void
1367ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
1368{
1369	struct buffer_head *bh = NULL;
1370
1371	if (!EXT4_I(inode)->i_file_acl)
1372		goto cleanup;
1373	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1374	if (!bh) {
1375		EXT4_ERROR_INODE(inode, "block %llu read error",
1376				 EXT4_I(inode)->i_file_acl);
1377		goto cleanup;
1378	}
1379	if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1380	    BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1381		EXT4_ERROR_INODE(inode, "bad block %llu",
1382				 EXT4_I(inode)->i_file_acl);
1383		goto cleanup;
1384	}
1385	ext4_xattr_release_block(handle, inode, bh);
1386	EXT4_I(inode)->i_file_acl = 0;
1387
1388cleanup:
1389	brelse(bh);
1390}
1391
1392/*
1393 * ext4_xattr_put_super()
1394 *
1395 * This is called when a file system is unmounted.
1396 */
1397void
1398ext4_xattr_put_super(struct super_block *sb)
1399{
1400	mb_cache_shrink(sb->s_bdev);
1401}
1402
1403/*
1404 * ext4_xattr_cache_insert()
1405 *
1406 * Create a new entry in the extended attribute cache, and insert
1407 * it unless such an entry is already in the cache.
1408 *
1409 * Returns 0, or a negative error number on failure.
1410 */
1411static void
1412ext4_xattr_cache_insert(struct buffer_head *bh)
1413{
1414	__u32 hash = le32_to_cpu(BHDR(bh)->h_hash);
1415	struct mb_cache_entry *ce;
1416	int error;
1417
1418	ce = mb_cache_entry_alloc(ext4_xattr_cache, GFP_NOFS);
1419	if (!ce) {
1420		ea_bdebug(bh, "out of memory");
1421		return;
1422	}
1423	error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, hash);
1424	if (error) {
1425		mb_cache_entry_free(ce);
1426		if (error == -EBUSY) {
1427			ea_bdebug(bh, "already in cache");
1428			error = 0;
1429		}
1430	} else {
1431		ea_bdebug(bh, "inserting [%x]", (int)hash);
1432		mb_cache_entry_release(ce);
1433	}
1434}
1435
1436/*
1437 * ext4_xattr_cmp()
1438 *
1439 * Compare two extended attribute blocks for equality.
1440 *
1441 * Returns 0 if the blocks are equal, 1 if they differ, and
1442 * a negative error number on errors.
1443 */
1444static int
1445ext4_xattr_cmp(struct ext4_xattr_header *header1,
1446	       struct ext4_xattr_header *header2)
1447{
1448	struct ext4_xattr_entry *entry1, *entry2;
1449
1450	entry1 = ENTRY(header1+1);
1451	entry2 = ENTRY(header2+1);
1452	while (!IS_LAST_ENTRY(entry1)) {
1453		if (IS_LAST_ENTRY(entry2))
1454			return 1;
1455		if (entry1->e_hash != entry2->e_hash ||
1456		    entry1->e_name_index != entry2->e_name_index ||
1457		    entry1->e_name_len != entry2->e_name_len ||
1458		    entry1->e_value_size != entry2->e_value_size ||
1459		    memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
1460			return 1;
1461		if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
1462			return -EIO;
1463		if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
1464			   (char *)header2 + le16_to_cpu(entry2->e_value_offs),
1465			   le32_to_cpu(entry1->e_value_size)))
1466			return 1;
1467
1468		entry1 = EXT4_XATTR_NEXT(entry1);
1469		entry2 = EXT4_XATTR_NEXT(entry2);
1470	}
1471	if (!IS_LAST_ENTRY(entry2))
1472		return 1;
1473	return 0;
1474}
1475
1476/*
1477 * ext4_xattr_cache_find()
1478 *
1479 * Find an identical extended attribute block.
1480 *
1481 * Returns a pointer to the block found, or NULL if such a block was
1482 * not found or an error occurred.
1483 */
1484static struct buffer_head *
1485ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
1486		      struct mb_cache_entry **pce)
1487{
1488	__u32 hash = le32_to_cpu(header->h_hash);
1489	struct mb_cache_entry *ce;
1490
1491	if (!header->h_hash)
1492		return NULL;  /* never share */
1493	ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
1494again:
1495	ce = mb_cache_entry_find_first(ext4_xattr_cache, inode->i_sb->s_bdev,
1496				       hash);
1497	while (ce) {
1498		struct buffer_head *bh;
1499
1500		if (IS_ERR(ce)) {
1501			if (PTR_ERR(ce) == -EAGAIN)
1502				goto again;
1503			break;
1504		}
1505		bh = sb_bread(inode->i_sb, ce->e_block);
1506		if (!bh) {
1507			EXT4_ERROR_INODE(inode, "block %lu read error",
1508					 (unsigned long) ce->e_block);
1509		} else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
1510				EXT4_XATTR_REFCOUNT_MAX) {
1511			ea_idebug(inode, "block %lu refcount %d>=%d",
1512				  (unsigned long) ce->e_block,
1513				  le32_to_cpu(BHDR(bh)->h_refcount),
1514					  EXT4_XATTR_REFCOUNT_MAX);
1515		} else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
1516			*pce = ce;
1517			return bh;
1518		}
1519		brelse(bh);
1520		ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash);
1521	}
1522	return NULL;
1523}
1524
1525#define NAME_HASH_SHIFT 5
1526#define VALUE_HASH_SHIFT 16
1527
1528/*
1529 * ext4_xattr_hash_entry()
1530 *
1531 * Compute the hash of an extended attribute.
1532 */
1533static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
1534					 struct ext4_xattr_entry *entry)
1535{
1536	__u32 hash = 0;
1537	char *name = entry->e_name;
1538	int n;
1539
1540	for (n = 0; n < entry->e_name_len; n++) {
1541		hash = (hash << NAME_HASH_SHIFT) ^
1542		       (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
1543		       *name++;
1544	}
1545
1546	if (entry->e_value_block == 0 && entry->e_value_size != 0) {
1547		__le32 *value = (__le32 *)((char *)header +
1548			le16_to_cpu(entry->e_value_offs));
1549		for (n = (le32_to_cpu(entry->e_value_size) +
1550		     EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
1551			hash = (hash << VALUE_HASH_SHIFT) ^
1552			       (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
1553			       le32_to_cpu(*value++);
1554		}
1555	}
1556	entry->e_hash = cpu_to_le32(hash);
1557}
1558
1559#undef NAME_HASH_SHIFT
1560#undef VALUE_HASH_SHIFT
1561
1562#define BLOCK_HASH_SHIFT 16
1563
1564/*
1565 * ext4_xattr_rehash()
1566 *
1567 * Re-compute the extended attribute hash value after an entry has changed.
1568 */
1569static void ext4_xattr_rehash(struct ext4_xattr_header *header,
1570			      struct ext4_xattr_entry *entry)
1571{
1572	struct ext4_xattr_entry *here;
1573	__u32 hash = 0;
1574
1575	ext4_xattr_hash_entry(header, entry);
1576	here = ENTRY(header+1);
1577	while (!IS_LAST_ENTRY(here)) {
1578		if (!here->e_hash) {
1579			/* Block is not shared if an entry's hash value == 0 */
1580			hash = 0;
1581			break;
1582		}
1583		hash = (hash << BLOCK_HASH_SHIFT) ^
1584		       (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
1585		       le32_to_cpu(here->e_hash);
1586		here = EXT4_XATTR_NEXT(here);
1587	}
1588	header->h_hash = cpu_to_le32(hash);
1589}
1590
1591#undef BLOCK_HASH_SHIFT
1592
1593int __init
1594ext4_init_xattr(void)
1595{
1596	ext4_xattr_cache = mb_cache_create("ext4_xattr", 6);
1597	if (!ext4_xattr_cache)
1598		return -ENOMEM;
1599	return 0;
1600}
1601
1602void
1603ext4_exit_xattr(void)
1604{
1605	if (ext4_xattr_cache)
1606		mb_cache_destroy(ext4_xattr_cache);
1607	ext4_xattr_cache = NULL;
1608}