xattr.c 48.2 KB
Newer Older
1
/*
2
 * linux/fs/ext4/xattr.c
3 4 5 6
 *
 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
 *
 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
7
 * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
 * Extended attributes for symlinks and special files added per
 *  suggestion of Luka Renko <luka.renko@hermes.si>.
 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
 *  Red Hat Inc.
 * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
 *  and Andreas Gruenbacher <agruen@suse.de>.
 */

/*
 * Extended attributes are stored directly in inodes (on file systems with
 * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
 * field contains the block number if an inode uses an additional block. All
 * attributes must fit in the inode and one additional block. Blocks that
 * contain the identical set of attributes may be shared among several inodes.
 * Identical blocks are detected by keeping a cache of blocks that have
 * recently been accessed.
 *
 * The attributes in inodes and on blocks have a different header; the entries
 * are stored in the same format:
 *
 *   +------------------+
 *   | header           |
 *   | entry 1          | |
 *   | entry 2          | | growing downwards
 *   | entry 3          | v
 *   | four null bytes  |
 *   | . . .            |
 *   | value 1          | ^
 *   | value 3          | | growing upwards
 *   | value 2          | |
 *   +------------------+
 *
 * The header is followed by multiple entry descriptors. In disk blocks, the
 * entry descriptors are kept sorted. In inodes, they are unsorted. The
 * attribute values are aligned to the end of the block in no specific order.
 *
 * Locking strategy
 * ----------------
46
 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
47 48 49 50 51 52 53 54 55
 * EA blocks are only changed if they are exclusive to an inode, so
 * holding xattr_sem also means that nothing but the EA block's reference
 * count can change. Multiple writers to the same block are synchronized
 * by the buffer lock.
 */

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
J
Jan Kara 已提交
56
#include <linux/mbcache.h>
57
#include <linux/quotaops.h>
58 59
#include "ext4_jbd2.h"
#include "ext4.h"
60 61 62
#include "xattr.h"
#include "acl.h"

63
#ifdef EXT4_XATTR_DEBUG
64 65 66 67 68 69 70
# define ea_idebug(inode, f...) do { \
		printk(KERN_DEBUG "inode %s:%lu: ", \
			inode->i_sb->s_id, inode->i_ino); \
		printk(f); \
		printk("\n"); \
	} while (0)
# define ea_bdebug(bh, f...) do { \
71 72
		printk(KERN_DEBUG "block %pg:%lu: ",		   \
		       bh->b_bdev, (unsigned long) bh->b_blocknr); \
73 74 75 76
		printk(f); \
		printk("\n"); \
	} while (0)
#else
77 78
# define ea_idebug(inode, fmt, ...)	no_printk(fmt, ##__VA_ARGS__)
# define ea_bdebug(bh, fmt, ...)	no_printk(fmt, ##__VA_ARGS__)
79 80
#endif

J
Jan Kara 已提交
81
static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
82 83
static struct buffer_head *ext4_xattr_cache_find(struct inode *,
						 struct ext4_xattr_header *,
J
Jan Kara 已提交
84
						 struct mb_cache_entry **);
85 86
static void ext4_xattr_rehash(struct ext4_xattr_header *,
			      struct ext4_xattr_entry *);
87
static int ext4_xattr_list(struct dentry *dentry, char *buffer,
88
			   size_t buffer_size);
89

S
Stephen Hemminger 已提交
90
static const struct xattr_handler *ext4_xattr_handler_map[] = {
91
	[EXT4_XATTR_INDEX_USER]		     = &ext4_xattr_user_handler,
T
Theodore Ts'o 已提交
92
#ifdef CONFIG_EXT4_FS_POSIX_ACL
93 94
	[EXT4_XATTR_INDEX_POSIX_ACL_ACCESS]  = &posix_acl_access_xattr_handler,
	[EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
95
#endif
96
	[EXT4_XATTR_INDEX_TRUSTED]	     = &ext4_xattr_trusted_handler,
T
Theodore Ts'o 已提交
97
#ifdef CONFIG_EXT4_FS_SECURITY
98
	[EXT4_XATTR_INDEX_SECURITY]	     = &ext4_xattr_security_handler,
99 100 101
#endif
};

S
Stephen Hemminger 已提交
102
const struct xattr_handler *ext4_xattr_handlers[] = {
103 104
	&ext4_xattr_user_handler,
	&ext4_xattr_trusted_handler,
T
Theodore Ts'o 已提交
105
#ifdef CONFIG_EXT4_FS_POSIX_ACL
106 107
	&posix_acl_access_xattr_handler,
	&posix_acl_default_xattr_handler,
108
#endif
T
Theodore Ts'o 已提交
109
#ifdef CONFIG_EXT4_FS_SECURITY
110
	&ext4_xattr_security_handler,
111 112 113 114
#endif
	NULL
};

115 116 117
#define EXT4_GET_MB_CACHE(inode)	(((struct ext4_sb_info *) \
				inode->i_sb->s_fs_info)->s_mb_cache)

118 119 120 121 122
static __le32 ext4_xattr_block_csum(struct inode *inode,
				    sector_t block_nr,
				    struct ext4_xattr_header *hdr)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
123 124
	__u32 csum;
	__le64 dsk_block_nr = cpu_to_le64(block_nr);
125 126
	__u32 dummy_csum = 0;
	int offset = offsetof(struct ext4_xattr_header, h_checksum);
127

128 129
	csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
			   sizeof(dsk_block_nr));
130 131 132 133 134
	csum = ext4_chksum(sbi, csum, (__u8 *)hdr, offset);
	csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
	offset += sizeof(dummy_csum);
	csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset,
			   EXT4_BLOCK_SIZE(inode->i_sb) - offset);
135

136 137 138 139 140 141 142
	return cpu_to_le32(csum);
}

static int ext4_xattr_block_csum_verify(struct inode *inode,
					sector_t block_nr,
					struct ext4_xattr_header *hdr)
{
143
	if (ext4_has_metadata_csum(inode->i_sb) &&
144 145 146 147 148 149 150 151 152
	    (hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr)))
		return 0;
	return 1;
}

static void ext4_xattr_block_csum_set(struct inode *inode,
				      sector_t block_nr,
				      struct ext4_xattr_header *hdr)
{
153
	if (!ext4_has_metadata_csum(inode->i_sb))
154 155 156 157 158 159 160 161 162 163 164 165 166
		return;

	hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr);
}

static inline int ext4_handle_dirty_xattr_block(handle_t *handle,
						struct inode *inode,
						struct buffer_head *bh)
{
	ext4_xattr_block_csum_set(inode, bh->b_blocknr, BHDR(bh));
	return ext4_handle_dirty_metadata(handle, inode, bh);
}

S
Stephen Hemminger 已提交
167
static inline const struct xattr_handler *
168
ext4_xattr_handler(int name_index)
169
{
S
Stephen Hemminger 已提交
170
	const struct xattr_handler *handler = NULL;
171

172 173
	if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
		handler = ext4_xattr_handler_map[name_index];
174 175 176 177 178 179
	return handler;
}

/*
 * Inode operation listxattr()
 *
180
 * d_inode(dentry)->i_mutex: don't care
181 182
 */
ssize_t
183
ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
184
{
185
	return ext4_xattr_list(dentry, buffer, size);
186 187 188
}

static int
189 190
ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
		       void *value_start)
191
{
192 193 194 195
	struct ext4_xattr_entry *e = entry;

	while (!IS_LAST_ENTRY(e)) {
		struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
196
		if ((void *)next >= end)
197
			return -EFSCORRUPTED;
198
		e = next;
199
	}
200 201 202 203 204 205 206

	while (!IS_LAST_ENTRY(entry)) {
		if (entry->e_value_size != 0 &&
		    (value_start + le16_to_cpu(entry->e_value_offs) <
		     (void *)e + sizeof(__u32) ||
		     value_start + le16_to_cpu(entry->e_value_offs) +
		    le32_to_cpu(entry->e_value_size) > end))
207
			return -EFSCORRUPTED;
208 209 210
		entry = EXT4_XATTR_NEXT(entry);
	}

211 212 213 214
	return 0;
}

static inline int
215
ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
216
{
217 218 219 220 221
	int error;

	if (buffer_verified(bh))
		return 0;

222
	if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
223
	    BHDR(bh)->h_blocks != cpu_to_le32(1))
224
		return -EFSCORRUPTED;
225
	if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
226
		return -EFSBADCRC;
227 228
	error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
				       bh->b_data);
229 230 231
	if (!error)
		set_buffer_verified(bh);
	return error;
232 233
}

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
static int
__xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,
			 void *end, const char *function, unsigned int line)
{
	struct ext4_xattr_entry *entry = IFIRST(header);
	int error = -EFSCORRUPTED;

	if (((void *) header >= end) ||
	    (header->h_magic != le32_to_cpu(EXT4_XATTR_MAGIC)))
		goto errout;
	error = ext4_xattr_check_names(entry, end, entry);
errout:
	if (error)
		__ext4_error_inode(inode, function, line, 0,
				   "corrupted in-inode xattr");
	return error;
}

#define xattr_check_inode(inode, header, end) \
	__xattr_check_inode((inode), (header), (end), __func__, __LINE__)

255
static inline int
256
ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
257 258 259 260 261
{
	size_t value_size = le32_to_cpu(entry->e_value_size);

	if (entry->e_value_block != 0 || value_size > size ||
	    le16_to_cpu(entry->e_value_offs) + value_size > size)
262
		return -EFSCORRUPTED;
263 264 265 266
	return 0;
}

static int
267
ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
268 269
		      const char *name, size_t size, int sorted)
{
270
	struct ext4_xattr_entry *entry;
271 272 273 274 275 276 277
	size_t name_len;
	int cmp = 1;

	if (name == NULL)
		return -EINVAL;
	name_len = strlen(name);
	entry = *pentry;
278
	for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
279 280 281 282 283 284 285 286 287
		cmp = name_index - entry->e_name_index;
		if (!cmp)
			cmp = name_len - entry->e_name_len;
		if (!cmp)
			cmp = memcmp(name, entry->e_name, name_len);
		if (cmp <= 0 && (sorted || cmp == 0))
			break;
	}
	*pentry = entry;
288
	if (!cmp && ext4_xattr_check_entry(entry, size))
289
		return -EFSCORRUPTED;
290 291 292 293
	return cmp ? -ENODATA : 0;
}

static int
294
ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
295 296 297
		     void *buffer, size_t buffer_size)
{
	struct buffer_head *bh = NULL;
298
	struct ext4_xattr_entry *entry;
299 300
	size_t size;
	int error;
J
Jan Kara 已提交
301
	struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
302 303 304 305 306

	ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
		  name_index, name, buffer, (long)buffer_size);

	error = -ENODATA;
307
	if (!EXT4_I(inode)->i_file_acl)
308
		goto cleanup;
309 310
	ea_idebug(inode, "reading block %llu",
		  (unsigned long long)EXT4_I(inode)->i_file_acl);
311
	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
312 313 314 315
	if (!bh)
		goto cleanup;
	ea_bdebug(bh, "b_count=%d, refcount=%d",
		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
316
	if (ext4_xattr_check_block(inode, bh)) {
317
bad_block:
318 319
		EXT4_ERROR_INODE(inode, "bad block %llu",
				 EXT4_I(inode)->i_file_acl);
320
		error = -EFSCORRUPTED;
321 322
		goto cleanup;
	}
323
	ext4_xattr_cache_insert(ext4_mb_cache, bh);
324
	entry = BFIRST(bh);
325
	error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
326
	if (error == -EFSCORRUPTED)
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
		goto bad_block;
	if (error)
		goto cleanup;
	size = le32_to_cpu(entry->e_value_size);
	if (buffer) {
		error = -ERANGE;
		if (size > buffer_size)
			goto cleanup;
		memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
		       size);
	}
	error = size;

cleanup:
	brelse(bh);
	return error;
}

T
Tao Ma 已提交
345
int
346
ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
347 348
		     void *buffer, size_t buffer_size)
{
349 350 351 352
	struct ext4_xattr_ibody_header *header;
	struct ext4_xattr_entry *entry;
	struct ext4_inode *raw_inode;
	struct ext4_iloc iloc;
353 354 355 356
	size_t size;
	void *end;
	int error;

357
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
358
		return -ENODATA;
359
	error = ext4_get_inode_loc(inode, &iloc);
360 361
	if (error)
		return error;
362
	raw_inode = ext4_raw_inode(&iloc);
363 364
	header = IHDR(inode, raw_inode);
	entry = IFIRST(header);
365
	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
366
	error = xattr_check_inode(inode, header, end);
367 368
	if (error)
		goto cleanup;
369
	error = ext4_xattr_find_entry(&entry, name_index, name,
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
				      end - (void *)entry, 0);
	if (error)
		goto cleanup;
	size = le32_to_cpu(entry->e_value_size);
	if (buffer) {
		error = -ERANGE;
		if (size > buffer_size)
			goto cleanup;
		memcpy(buffer, (void *)IFIRST(header) +
		       le16_to_cpu(entry->e_value_offs), size);
	}
	error = size;

cleanup:
	brelse(iloc.bh);
	return error;
}

/*
389
 * ext4_xattr_get()
390 391 392 393 394 395 396 397 398
 *
 * Copy an extended attribute into the buffer
 * provided, or compute the buffer size required.
 * Buffer is NULL to compute the size of the buffer required.
 *
 * Returns a negative error number on failure, or the number of bytes
 * used / required on success.
 */
int
399
ext4_xattr_get(struct inode *inode, int name_index, const char *name,
400 401 402 403
	       void *buffer, size_t buffer_size)
{
	int error;

404 405 406
	if (strlen(name) > 255)
		return -ERANGE;

407 408
	down_read(&EXT4_I(inode)->xattr_sem);
	error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
409 410
				     buffer_size);
	if (error == -ENODATA)
411
		error = ext4_xattr_block_get(inode, name_index, name, buffer,
412
					     buffer_size);
413
	up_read(&EXT4_I(inode)->xattr_sem);
414 415 416 417
	return error;
}

static int
418
ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
419 420 421 422
			char *buffer, size_t buffer_size)
{
	size_t rest = buffer_size;

423
	for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
S
Stephen Hemminger 已提交
424
		const struct xattr_handler *handler =
425
			ext4_xattr_handler(entry->e_name_index);
426

427 428 429 430 431
		if (handler && (!handler->list || handler->list(dentry))) {
			const char *prefix = handler->prefix ?: handler->name;
			size_t prefix_len = strlen(prefix);
			size_t size = prefix_len + entry->e_name_len + 1;

432 433 434
			if (buffer) {
				if (size > rest)
					return -ERANGE;
435 436 437 438 439
				memcpy(buffer, prefix, prefix_len);
				buffer += prefix_len;
				memcpy(buffer, entry->e_name, entry->e_name_len);
				buffer += entry->e_name_len;
				*buffer++ = 0;
440 441 442 443
			}
			rest -= size;
		}
	}
444
	return buffer_size - rest;  /* total size */
445 446 447
}

static int
448
ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
449
{
450
	struct inode *inode = d_inode(dentry);
451 452
	struct buffer_head *bh = NULL;
	int error;
J
Jan Kara 已提交
453
	struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
454 455 456 457 458

	ea_idebug(inode, "buffer=%p, buffer_size=%ld",
		  buffer, (long)buffer_size);

	error = 0;
459
	if (!EXT4_I(inode)->i_file_acl)
460
		goto cleanup;
461 462
	ea_idebug(inode, "reading block %llu",
		  (unsigned long long)EXT4_I(inode)->i_file_acl);
463
	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
464 465 466 467 468
	error = -EIO;
	if (!bh)
		goto cleanup;
	ea_bdebug(bh, "b_count=%d, refcount=%d",
		atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
469
	if (ext4_xattr_check_block(inode, bh)) {
470 471
		EXT4_ERROR_INODE(inode, "bad block %llu",
				 EXT4_I(inode)->i_file_acl);
472
		error = -EFSCORRUPTED;
473 474
		goto cleanup;
	}
475
	ext4_xattr_cache_insert(ext4_mb_cache, bh);
476
	error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
477 478 479 480 481 482 483 484

cleanup:
	brelse(bh);

	return error;
}

static int
485
ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
486
{
487
	struct inode *inode = d_inode(dentry);
488 489 490
	struct ext4_xattr_ibody_header *header;
	struct ext4_inode *raw_inode;
	struct ext4_iloc iloc;
491 492 493
	void *end;
	int error;

494
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
495
		return 0;
496
	error = ext4_get_inode_loc(inode, &iloc);
497 498
	if (error)
		return error;
499
	raw_inode = ext4_raw_inode(&iloc);
500
	header = IHDR(inode, raw_inode);
501
	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
502
	error = xattr_check_inode(inode, header, end);
503 504
	if (error)
		goto cleanup;
505
	error = ext4_xattr_list_entries(dentry, IFIRST(header),
506 507 508 509 510 511 512 513
					buffer, buffer_size);

cleanup:
	brelse(iloc.bh);
	return error;
}

/*
514
 * ext4_xattr_list()
515 516 517 518 519 520 521 522
 *
 * Copy a list of attribute names into the buffer
 * provided, or compute the buffer size required.
 * Buffer is NULL to compute the size of the buffer required.
 *
 * Returns a negative error number on failure, or the number of bytes
 * used / required on success.
 */
523
static int
524
ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
525
{
526
	int ret, ret2;
527

528
	down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
529 530 531 532 533 534
	ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
	if (ret < 0)
		goto errout;
	if (buffer) {
		buffer += ret;
		buffer_size -= ret;
535
	}
536 537 538 539 540
	ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
	if (ret < 0)
		goto errout;
	ret += ret2;
errout:
541
	up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
542
	return ret;
543 544 545
}

/*
546
 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
547 548
 * not set, set it.
 */
549
static void ext4_xattr_update_super_block(handle_t *handle,
550 551
					  struct super_block *sb)
{
552
	if (ext4_has_feature_xattr(sb))
553 554
		return;

555
	BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
556
	if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
557
		ext4_set_feature_xattr(sb);
T
Theodore Ts'o 已提交
558
		ext4_handle_dirty_super(handle, sb);
559 560 561 562
	}
}

/*
563 564
 * Release the xattr block BH: If the reference count is > 1, decrement it;
 * otherwise free the block.
565 566
 */
static void
567
ext4_xattr_release_block(handle_t *handle, struct inode *inode,
568 569
			 struct buffer_head *bh)
{
570 571
	struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
	u32 hash, ref;
572
	int error = 0;
573

574
	BUFFER_TRACE(bh, "get_write_access");
575 576 577 578 579
	error = ext4_journal_get_write_access(handle, bh);
	if (error)
		goto out;

	lock_buffer(bh);
580 581 582
	hash = le32_to_cpu(BHDR(bh)->h_hash);
	ref = le32_to_cpu(BHDR(bh)->h_refcount);
	if (ref == 1) {
583
		ea_bdebug(bh, "refcount now=0; freeing");
J
Jan Kara 已提交
584 585 586 587
		/*
		 * This must happen under buffer lock for
		 * ext4_xattr_block_set() to reliably detect freed block
		 */
588
		mb_cache_entry_delete_block(ext4_mb_cache, hash, bh->b_blocknr);
589
		get_bh(bh);
590
		unlock_buffer(bh);
591 592 593
		ext4_free_blocks(handle, inode, bh, 0, 1,
				 EXT4_FREE_BLOCKS_METADATA |
				 EXT4_FREE_BLOCKS_FORGET);
594
	} else {
595 596 597 598 599 600 601 602 603 604 605 606 607
		ref--;
		BHDR(bh)->h_refcount = cpu_to_le32(ref);
		if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
			struct mb_cache_entry *ce;

			ce = mb_cache_entry_get(ext4_mb_cache, hash,
						bh->b_blocknr);
			if (ce) {
				ce->e_reusable = 1;
				mb_cache_entry_put(ext4_mb_cache, ce);
			}
		}

608 609 610 611 612 613 614 615 616 617 618 619 620
		/*
		 * Beware of this ugliness: Releasing of xattr block references
		 * from different inodes can race and so we have to protect
		 * from a race where someone else frees the block (and releases
		 * its journal_head) before we are done dirtying the buffer. In
		 * nojournal mode this race is harmless and we actually cannot
		 * call ext4_handle_dirty_xattr_block() with locked buffer as
		 * that function can call sync_dirty_buffer() so for that case
		 * we handle the dirtying after unlocking the buffer.
		 */
		if (ext4_handle_valid(handle))
			error = ext4_handle_dirty_xattr_block(handle, inode,
							      bh);
621
		unlock_buffer(bh);
622 623 624
		if (!ext4_handle_valid(handle))
			error = ext4_handle_dirty_xattr_block(handle, inode,
							      bh);
625
		if (IS_SYNC(inode))
626
			ext4_handle_sync(handle);
627
		dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
628 629
		ea_bdebug(bh, "refcount now=%d; releasing",
			  le32_to_cpu(BHDR(bh)->h_refcount));
630
	}
631 632 633
out:
	ext4_std_error(inode->i_sb, error);
	return;
634 635
}

636 637 638 639 640 641 642 643 644 645 646 647 648
/*
 * Find the available free space for EAs. This also returns the total number of
 * bytes used by EA entries.
 */
static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
				    size_t *min_offs, void *base, int *total)
{
	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
		if (!last->e_value_block && last->e_value_size) {
			size_t offs = le16_to_cpu(last->e_value_offs);
			if (offs < *min_offs)
				*min_offs = offs;
		}
649 650
		if (total)
			*total += EXT4_XATTR_LEN(last->e_name_len);
651 652 653 654
	}
	return (*min_offs - ((void *)last - base) - sizeof(__u32));
}

655
static int
656
ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
657
{
658
	struct ext4_xattr_entry *last;
659 660 661 662
	size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);

	/* Compute min_offs and last. */
	last = s->first;
663
	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
664 665 666 667 668 669 670 671 672 673
		if (!last->e_value_block && last->e_value_size) {
			size_t offs = le16_to_cpu(last->e_value_offs);
			if (offs < min_offs)
				min_offs = offs;
		}
	}
	free = min_offs - ((void *)last - s->base) - sizeof(__u32);
	if (!s->not_found) {
		if (!s->here->e_value_block && s->here->e_value_size) {
			size_t size = le32_to_cpu(s->here->e_value_size);
674
			free += EXT4_XATTR_SIZE(size);
675
		}
676
		free += EXT4_XATTR_LEN(name_len);
677 678
	}
	if (i->value) {
679
		if (free < EXT4_XATTR_LEN(name_len) +
680
			   EXT4_XATTR_SIZE(i->value_len))
681 682 683 684 685
			return -ENOSPC;
	}

	if (i->value && s->not_found) {
		/* Insert the new name. */
686
		size_t size = EXT4_XATTR_LEN(name_len);
687 688 689 690 691 692 693 694 695 696 697
		size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
		memmove((void *)s->here + size, s->here, rest);
		memset(s->here, 0, size);
		s->here->e_name_index = i->name_index;
		s->here->e_name_len = name_len;
		memcpy(s->here->e_name, i->name, name_len);
	} else {
		if (!s->here->e_value_block && s->here->e_value_size) {
			void *first_val = s->base + min_offs;
			size_t offs = le16_to_cpu(s->here->e_value_offs);
			void *val = s->base + offs;
698
			size_t size = EXT4_XATTR_SIZE(
699 700
				le32_to_cpu(s->here->e_value_size));

701
			if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
702 703 704 705
				/* The old and the new value have the same
				   size. Just replace. */
				s->here->e_value_size =
					cpu_to_le32(i->value_len);
706 707 708 709 710 711 712 713
				if (i->value == EXT4_ZERO_XATTR_VALUE) {
					memset(val, 0, size);
				} else {
					/* Clear pad bytes first. */
					memset(val + size - EXT4_XATTR_PAD, 0,
					       EXT4_XATTR_PAD);
					memcpy(val, i->value, i->value_len);
				}
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
				return 0;
			}

			/* Remove the old value. */
			memmove(first_val + size, first_val, val - first_val);
			memset(first_val, 0, size);
			s->here->e_value_size = 0;
			s->here->e_value_offs = 0;
			min_offs += size;

			/* Adjust all value offsets. */
			last = s->first;
			while (!IS_LAST_ENTRY(last)) {
				size_t o = le16_to_cpu(last->e_value_offs);
				if (!last->e_value_block &&
				    last->e_value_size && o < offs)
					last->e_value_offs =
						cpu_to_le16(o + size);
732
				last = EXT4_XATTR_NEXT(last);
733 734 735 736
			}
		}
		if (!i->value) {
			/* Remove the old name. */
737
			size_t size = EXT4_XATTR_LEN(name_len);
738 739 740 741 742 743 744 745 746 747 748
			last = ENTRY((void *)last - size);
			memmove(s->here, (void *)s->here + size,
				(void *)last - (void *)s->here + sizeof(__u32));
			memset(last, 0, size);
		}
	}

	if (i->value) {
		/* Insert the new value. */
		s->here->e_value_size = cpu_to_le32(i->value_len);
		if (i->value_len) {
749
			size_t size = EXT4_XATTR_SIZE(i->value_len);
750 751
			void *val = s->base + min_offs - size;
			s->here->e_value_offs = cpu_to_le16(min_offs - size);
752 753 754 755 756 757 758 759
			if (i->value == EXT4_ZERO_XATTR_VALUE) {
				memset(val, 0, size);
			} else {
				/* Clear the pad bytes first. */
				memset(val + size - EXT4_XATTR_PAD, 0,
				       EXT4_XATTR_PAD);
				memcpy(val, i->value, i->value_len);
			}
760 761 762 763 764
		}
	}
	return 0;
}

765 766
struct ext4_xattr_block_find {
	struct ext4_xattr_search s;
767 768 769 770
	struct buffer_head *bh;
};

static int
771 772
ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
		      struct ext4_xattr_block_find *bs)
773 774 775 776 777 778 779
{
	struct super_block *sb = inode->i_sb;
	int error;

	ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
		  i->name_index, i->name, i->value, (long)i->value_len);

780
	if (EXT4_I(inode)->i_file_acl) {
781
		/* The inode already has an extended attribute block. */
782
		bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
783 784 785 786 787 788
		error = -EIO;
		if (!bs->bh)
			goto cleanup;
		ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
			atomic_read(&(bs->bh->b_count)),
			le32_to_cpu(BHDR(bs->bh)->h_refcount));
789
		if (ext4_xattr_check_block(inode, bs->bh)) {
790 791
			EXT4_ERROR_INODE(inode, "bad block %llu",
					 EXT4_I(inode)->i_file_acl);
792
			error = -EFSCORRUPTED;
793 794 795 796 797 798 799
			goto cleanup;
		}
		/* Find the named attribute. */
		bs->s.base = BHDR(bs->bh);
		bs->s.first = BFIRST(bs->bh);
		bs->s.end = bs->bh->b_data + bs->bh->b_size;
		bs->s.here = bs->s.first;
800
		error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
801 802 803 804 805 806 807 808 809 810 811 812
					      i->name, bs->bh->b_size, 1);
		if (error && error != -ENODATA)
			goto cleanup;
		bs->s.not_found = error;
	}
	error = 0;

cleanup:
	return error;
}

static int
813 814 815
ext4_xattr_block_set(handle_t *handle, struct inode *inode,
		     struct ext4_xattr_info *i,
		     struct ext4_xattr_block_find *bs)
816 817 818
{
	struct super_block *sb = inode->i_sb;
	struct buffer_head *new_bh = NULL;
819
	struct ext4_xattr_search *s = &bs->s;
J
Jan Kara 已提交
820
	struct mb_cache_entry *ce = NULL;
821
	int error = 0;
J
Jan Kara 已提交
822
	struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
823

824
#define header(x) ((struct ext4_xattr_header *)(x))
825 826 827 828

	if (i->value && i->value_len > sb->s_blocksize)
		return -ENOSPC;
	if (s->base) {
829
		BUFFER_TRACE(bs->bh, "get_write_access");
830 831 832 833 834
		error = ext4_journal_get_write_access(handle, bs->bh);
		if (error)
			goto cleanup;
		lock_buffer(bs->bh);

835
		if (header(s->base)->h_refcount == cpu_to_le32(1)) {
J
Jan Kara 已提交
836 837 838 839 840 841 842
			__u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);

			/*
			 * This must happen under buffer lock for
			 * ext4_xattr_block_set() to reliably detect modified
			 * block
			 */
J
Jan Kara 已提交
843 844
			mb_cache_entry_delete_block(ext4_mb_cache, hash,
						    bs->bh->b_blocknr);
845
			ea_bdebug(bs->bh, "modifying in-place");
846
			error = ext4_xattr_set_entry(i, s);
847 848
			if (!error) {
				if (!IS_LAST_ENTRY(s->first))
849
					ext4_xattr_rehash(header(s->base),
850
							  s->here);
851 852
				ext4_xattr_cache_insert(ext4_mb_cache,
					bs->bh);
853 854
			}
			unlock_buffer(bs->bh);
855
			if (error == -EFSCORRUPTED)
856 857
				goto bad_block;
			if (!error)
858 859 860
				error = ext4_handle_dirty_xattr_block(handle,
								      inode,
								      bs->bh);
861 862 863 864 865 866
			if (error)
				goto cleanup;
			goto inserted;
		} else {
			int offset = (char *)s->here - bs->bh->b_data;

867
			unlock_buffer(bs->bh);
868
			ea_bdebug(bs->bh, "cloning");
869
			s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
870 871 872 873 874 875 876 877 878 879 880
			error = -ENOMEM;
			if (s->base == NULL)
				goto cleanup;
			memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
			s->first = ENTRY(header(s->base)+1);
			header(s->base)->h_refcount = cpu_to_le32(1);
			s->here = ENTRY(s->base + offset);
			s->end = s->base + bs->bh->b_size;
		}
	} else {
		/* Allocate a buffer where we construct the new block. */
881
		s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
882 883 884 885
		/* assert(header == s->base) */
		error = -ENOMEM;
		if (s->base == NULL)
			goto cleanup;
886
		header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
887 888 889 890 891 892 893
		header(s->base)->h_blocks = cpu_to_le32(1);
		header(s->base)->h_refcount = cpu_to_le32(1);
		s->first = ENTRY(header(s->base)+1);
		s->here = ENTRY(header(s->base)+1);
		s->end = s->base + sb->s_blocksize;
	}

894
	error = ext4_xattr_set_entry(i, s);
895
	if (error == -EFSCORRUPTED)
896 897 898 899
		goto bad_block;
	if (error)
		goto cleanup;
	if (!IS_LAST_ENTRY(s->first))
900
		ext4_xattr_rehash(header(s->base), s->here);
901 902 903

inserted:
	if (!IS_LAST_ENTRY(s->first)) {
904
		new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
905 906 907 908 909
		if (new_bh) {
			/* We found an identical block in the cache. */
			if (new_bh == bs->bh)
				ea_bdebug(new_bh, "keeping");
			else {
910 911
				u32 ref;

912 913
				/* The old block is released after updating
				   the inode. */
914 915
				error = dquot_alloc_block(inode,
						EXT4_C2B(EXT4_SB(sb), 1));
916
				if (error)
917
					goto cleanup;
918
				BUFFER_TRACE(new_bh, "get_write_access");
919
				error = ext4_journal_get_write_access(handle,
920 921 922 923
								      new_bh);
				if (error)
					goto cleanup_dquot;
				lock_buffer(new_bh);
J
Jan Kara 已提交
924 925
				/*
				 * We have to be careful about races with
926 927 928 929 930 931 932 933 934
				 * freeing, rehashing or adding references to
				 * xattr block. Once we hold buffer lock xattr
				 * block's state is stable so we can check
				 * whether the block got freed / rehashed or
				 * not.  Since we unhash mbcache entry under
				 * buffer lock when freeing / rehashing xattr
				 * block, checking whether entry is still
				 * hashed is reliable. Same rules hold for
				 * e_reusable handling.
J
Jan Kara 已提交
935
				 */
936 937
				if (hlist_bl_unhashed(&ce->e_hash_list) ||
				    !ce->e_reusable) {
J
Jan Kara 已提交
938 939 940 941 942 943 944 945 946
					/*
					 * Undo everything and check mbcache
					 * again.
					 */
					unlock_buffer(new_bh);
					dquot_free_block(inode,
							 EXT4_C2B(EXT4_SB(sb),
								  1));
					brelse(new_bh);
J
Jan Kara 已提交
947
					mb_cache_entry_put(ext4_mb_cache, ce);
J
Jan Kara 已提交
948 949 950 951
					ce = NULL;
					new_bh = NULL;
					goto inserted;
				}
952 953 954 955
				ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
				BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
				if (ref >= EXT4_XATTR_REFCOUNT_MAX)
					ce->e_reusable = 0;
956
				ea_bdebug(new_bh, "reusing; refcount now=%d",
957
					  ref);
958
				unlock_buffer(new_bh);
959 960 961
				error = ext4_handle_dirty_xattr_block(handle,
								      inode,
								      new_bh);
962 963 964
				if (error)
					goto cleanup_dquot;
			}
J
Jan Kara 已提交
965 966
			mb_cache_entry_touch(ext4_mb_cache, ce);
			mb_cache_entry_put(ext4_mb_cache, ce);
967 968 969 970 971 972 973 974
			ce = NULL;
		} else if (bs->bh && s->base == bs->bh->b_data) {
			/* We were modifying this block in-place. */
			ea_bdebug(bs->bh, "keeping this block");
			new_bh = bs->bh;
			get_bh(new_bh);
		} else {
			/* We need to allocate a new block */
975 976 977
			ext4_fsblk_t goal, block;

			goal = ext4_group_first_block_no(sb,
978
						EXT4_I(inode)->i_block_group);
979 980

			/* non-extent files can't have physical blocks past 2^32 */
981
			if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
982 983
				goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;

984 985
			block = ext4_new_meta_blocks(handle, inode, goal, 0,
						     NULL, &error);
986 987
			if (error)
				goto cleanup;
988

989
			if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
990 991
				BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);

992 993
			ea_idebug(inode, "creating block %llu",
				  (unsigned long long)block);
994 995

			new_bh = sb_getblk(sb, block);
996
			if (unlikely(!new_bh)) {
997
				error = -ENOMEM;
998
getblk_failed:
999
				ext4_free_blocks(handle, inode, NULL, block, 1,
1000
						 EXT4_FREE_BLOCKS_METADATA);
1001 1002 1003
				goto cleanup;
			}
			lock_buffer(new_bh);
1004
			error = ext4_journal_get_create_access(handle, new_bh);
1005 1006
			if (error) {
				unlock_buffer(new_bh);
1007
				error = -EIO;
1008 1009 1010 1011 1012
				goto getblk_failed;
			}
			memcpy(new_bh->b_data, s->base, new_bh->b_size);
			set_buffer_uptodate(new_bh);
			unlock_buffer(new_bh);
1013
			ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
1014 1015
			error = ext4_handle_dirty_xattr_block(handle,
							      inode, new_bh);
1016 1017 1018 1019 1020 1021
			if (error)
				goto cleanup;
		}
	}

	/* Update the inode. */
1022
	EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
1023 1024 1025

	/* Drop the previous xattr block. */
	if (bs->bh && bs->bh != new_bh)
1026
		ext4_xattr_release_block(handle, inode, bs->bh);
1027 1028 1029 1030
	error = 0;

cleanup:
	if (ce)
J
Jan Kara 已提交
1031
		mb_cache_entry_put(ext4_mb_cache, ce);
1032 1033 1034 1035 1036 1037 1038
	brelse(new_bh);
	if (!(bs->bh && s->base == bs->bh->b_data))
		kfree(s->base);

	return error;

cleanup_dquot:
1039
	dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
1040 1041 1042
	goto cleanup;

bad_block:
1043 1044
	EXT4_ERROR_INODE(inode, "bad block %llu",
			 EXT4_I(inode)->i_file_acl);
1045 1046 1047 1048 1049
	goto cleanup;

#undef header
}

T
Tao Ma 已提交
1050 1051
int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
			  struct ext4_xattr_ibody_find *is)
1052
{
1053 1054
	struct ext4_xattr_ibody_header *header;
	struct ext4_inode *raw_inode;
1055 1056
	int error;

1057
	if (EXT4_I(inode)->i_extra_isize == 0)
1058
		return 0;
1059
	raw_inode = ext4_raw_inode(&is->iloc);
1060 1061 1062
	header = IHDR(inode, raw_inode);
	is->s.base = is->s.first = IFIRST(header);
	is->s.here = is->s.first;
1063
	is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
1064
	if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
1065
		error = xattr_check_inode(inode, header, is->s.end);
1066 1067 1068
		if (error)
			return error;
		/* Find the named attribute. */
1069
		error = ext4_xattr_find_entry(&is->s.here, i->name_index,
1070 1071 1072 1073 1074 1075 1076 1077 1078
					      i->name, is->s.end -
					      (void *)is->s.base, 0);
		if (error && error != -ENODATA)
			return error;
		is->s.not_found = error;
	}
	return 0;
}

1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
				struct ext4_xattr_info *i,
				struct ext4_xattr_ibody_find *is)
{
	struct ext4_xattr_ibody_header *header;
	struct ext4_xattr_search *s = &is->s;
	int error;

	if (EXT4_I(inode)->i_extra_isize == 0)
		return -ENOSPC;
	error = ext4_xattr_set_entry(i, s);
	if (error) {
		if (error == -ENOSPC &&
		    ext4_has_inline_data(inode)) {
			error = ext4_try_to_evict_inline_data(handle, inode,
					EXT4_XATTR_LEN(strlen(i->name) +
					EXT4_XATTR_SIZE(i->value_len)));
			if (error)
				return error;
			error = ext4_xattr_ibody_find(inode, i, is);
			if (error)
				return error;
			error = ext4_xattr_set_entry(i, s);
		}
		if (error)
			return error;
	}
	header = IHDR(inode, ext4_raw_inode(&is->iloc));
	if (!IS_LAST_ENTRY(s->first)) {
		header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
	} else {
		header->h_magic = cpu_to_le32(0);
		ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
	}
	return 0;
}

static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
				struct ext4_xattr_info *i,
				struct ext4_xattr_ibody_find *is)
1120
{
1121 1122
	struct ext4_xattr_ibody_header *header;
	struct ext4_xattr_search *s = &is->s;
1123 1124
	int error;

1125
	if (EXT4_I(inode)->i_extra_isize == 0)
1126
		return -ENOSPC;
1127
	error = ext4_xattr_set_entry(i, s);
1128 1129
	if (error)
		return error;
1130
	header = IHDR(inode, ext4_raw_inode(&is->iloc));
1131
	if (!IS_LAST_ENTRY(s->first)) {
1132
		header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
1133
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
1134 1135
	} else {
		header->h_magic = cpu_to_le32(0);
1136
		ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
1137 1138 1139 1140
	}
	return 0;
}

1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
static int ext4_xattr_value_same(struct ext4_xattr_search *s,
				 struct ext4_xattr_info *i)
{
	void *value;

	if (le32_to_cpu(s->here->e_value_size) != i->value_len)
		return 0;
	value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
	return !memcmp(value, i->value, i->value_len);
}

1152
/*
1153
 * ext4_xattr_set_handle()
1154
 *
1155
 * Create, replace or remove an extended attribute for this inode.  Value
1156 1157 1158 1159 1160 1161 1162 1163 1164
 * is NULL to remove an existing extended attribute, and non-NULL to
 * either replace an existing extended attribute, or create a new extended
 * attribute. The flags XATTR_REPLACE and XATTR_CREATE
 * specify that an extended attribute must exist and must not exist
 * previous to the call, respectively.
 *
 * Returns 0, or a negative error number on failure.
 */
int
1165
ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
1166 1167 1168
		      const char *name, const void *value, size_t value_len,
		      int flags)
{
1169
	struct ext4_xattr_info i = {
1170 1171 1172 1173 1174 1175
		.name_index = name_index,
		.name = name,
		.value = value,
		.value_len = value_len,

	};
1176
	struct ext4_xattr_ibody_find is = {
1177 1178
		.s = { .not_found = -ENODATA, },
	};
1179
	struct ext4_xattr_block_find bs = {
1180 1181
		.s = { .not_found = -ENODATA, },
	};
K
Kalpak Shah 已提交
1182
	unsigned long no_expand;
1183 1184 1185 1186 1187 1188
	int error;

	if (!name)
		return -EINVAL;
	if (strlen(name) > 255)
		return -ERANGE;
1189
	down_write(&EXT4_I(inode)->xattr_sem);
1190 1191
	no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
	ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
K
Kalpak Shah 已提交
1192

1193
	error = ext4_reserve_inode_write(handle, inode, &is.iloc);
1194 1195 1196
	if (error)
		goto cleanup;

1197
	if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
1198 1199
		struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
1200
		ext4_clear_inode_state(inode, EXT4_STATE_NEW);
1201 1202
	}

1203
	error = ext4_xattr_ibody_find(inode, &i, &is);
1204 1205 1206
	if (error)
		goto cleanup;
	if (is.s.not_found)
1207
		error = ext4_xattr_block_find(inode, &i, &bs);
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
	if (error)
		goto cleanup;
	if (is.s.not_found && bs.s.not_found) {
		error = -ENODATA;
		if (flags & XATTR_REPLACE)
			goto cleanup;
		error = 0;
		if (!value)
			goto cleanup;
	} else {
		error = -EEXIST;
		if (flags & XATTR_CREATE)
			goto cleanup;
	}
	if (!value) {
		if (!is.s.not_found)
1224
			error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1225
		else if (!bs.s.not_found)
1226
			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1227
	} else {
1228 1229 1230 1231 1232 1233 1234
		error = 0;
		/* Xattr value did not change? Save us some work and bail out */
		if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
			goto cleanup;
		if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
			goto cleanup;

1235
		error = ext4_xattr_ibody_set(handle, inode, &i, &is);
1236 1237
		if (!error && !bs.s.not_found) {
			i.value = NULL;
1238
			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1239
		} else if (error == -ENOSPC) {
1240 1241 1242 1243 1244
			if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
				error = ext4_xattr_block_find(inode, &i, &bs);
				if (error)
					goto cleanup;
			}
1245
			error = ext4_xattr_block_set(handle, inode, &i, &bs);
1246 1247 1248 1249
			if (error)
				goto cleanup;
			if (!is.s.not_found) {
				i.value = NULL;
1250
				error = ext4_xattr_ibody_set(handle, inode, &i,
1251 1252 1253 1254 1255
							     &is);
			}
		}
	}
	if (!error) {
1256
		ext4_xattr_update_super_block(handle, inode->i_sb);
K
Kalpak Shah 已提交
1257
		inode->i_ctime = ext4_current_time(inode);
1258
		if (!value)
1259
			ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1260
		error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
1261
		/*
1262
		 * The bh is consumed by ext4_mark_iloc_dirty, even with
1263 1264 1265 1266
		 * error != 0.
		 */
		is.iloc.bh = NULL;
		if (IS_SYNC(inode))
1267
			ext4_handle_sync(handle);
1268 1269 1270 1271 1272
	}

cleanup:
	brelse(is.iloc.bh);
	brelse(bs.bh);
K
Kalpak Shah 已提交
1273
	if (no_expand == 0)
1274
		ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
1275
	up_write(&EXT4_I(inode)->xattr_sem);
1276 1277 1278 1279
	return error;
}

/*
1280
 * ext4_xattr_set()
1281
 *
1282
 * Like ext4_xattr_set_handle, but start from an inode. This extended
1283 1284 1285 1286 1287
 * attribute modification is a filesystem transaction by itself.
 *
 * Returns 0, or a negative error number on failure.
 */
int
1288
ext4_xattr_set(struct inode *inode, int name_index, const char *name,
1289 1290 1291 1292
	       const void *value, size_t value_len, int flags)
{
	handle_t *handle;
	int error, retries = 0;
1293
	int credits = ext4_jbd2_credits_xattr(inode);
1294 1295

retry:
1296
	handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
1297 1298 1299 1300 1301
	if (IS_ERR(handle)) {
		error = PTR_ERR(handle);
	} else {
		int error2;

1302
		error = ext4_xattr_set_handle(handle, inode, name_index, name,
1303
					      value, value_len, flags);
1304
		error2 = ext4_journal_stop(handle);
1305
		if (error == -ENOSPC &&
1306
		    ext4_should_retry_alloc(inode->i_sb, &retries))
1307 1308 1309 1310 1311 1312 1313 1314
			goto retry;
		if (error == 0)
			error = error2;
	}

	return error;
}

1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
/*
 * Shift the EA entries in the inode to create space for the increased
 * i_extra_isize.
 */
static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
				     int value_offs_shift, void *to,
				     void *from, size_t n, int blocksize)
{
	struct ext4_xattr_entry *last = entry;
	int new_offs;

	/* Adjust the value offsets of the entries */
	for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
		if (!last->e_value_block && last->e_value_size) {
			new_offs = le16_to_cpu(last->e_value_offs) +
							value_offs_shift;
			BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
				 > blocksize);
			last->e_value_offs = cpu_to_le16(new_offs);
		}
	}
	/* Shift the entries by n bytes */
	memmove(to, from, n);
}

/*
 * Expand an inode by new_extra_isize bytes when EAs are present.
 * Returns 0 on success or negative error number on failure.
 */
int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
			       struct ext4_inode *raw_inode, handle_t *handle)
{
	struct ext4_xattr_ibody_header *header;
	struct ext4_xattr_entry *entry, *last, *first;
	struct buffer_head *bh = NULL;
	struct ext4_xattr_ibody_find *is = NULL;
	struct ext4_xattr_block_find *bs = NULL;
	char *buffer = NULL, *b_entry_name = NULL;
	size_t min_offs, free;
1354
	int total_ino;
1355
	void *base, *start, *end;
1356
	int error = 0, tried_min_extra_isize = 0;
A
Aneesh Kumar K.V 已提交
1357
	int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
1358
	int isize_diff;	/* How much do we need to grow i_extra_isize */
1359 1360 1361

	down_write(&EXT4_I(inode)->xattr_sem);
retry:
1362
	isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;
1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
		up_write(&EXT4_I(inode)->xattr_sem);
		return 0;
	}

	header = IHDR(inode, raw_inode);
	entry = IFIRST(header);

	/*
	 * Check if enough free space is available in the inode to shift the
	 * entries ahead by new_extra_isize.
	 */

	base = start = entry;
	end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
	min_offs = end - base;
	last = entry;
	total_ino = sizeof(struct ext4_xattr_ibody_header);

1382 1383 1384 1385
	error = xattr_check_inode(inode, header, end);
	if (error)
		goto cleanup;

1386
	free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
1387
	if (free >= isize_diff) {
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
		entry = IFIRST(header);
		ext4_xattr_shift_entries(entry,	EXT4_I(inode)->i_extra_isize
				- new_extra_isize, (void *)raw_inode +
				EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
				(void *)header, total_ino,
				inode->i_sb->s_blocksize);
		EXT4_I(inode)->i_extra_isize = new_extra_isize;
		error = 0;
		goto cleanup;
	}

	/*
	 * Enough free space isn't available in the inode, check if
	 * EA block can hold new_extra_isize bytes.
	 */
	if (EXT4_I(inode)->i_file_acl) {
		bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
		error = -EIO;
		if (!bh)
			goto cleanup;
1408
		if (ext4_xattr_check_block(inode, bh)) {
1409 1410
			EXT4_ERROR_INODE(inode, "bad block %llu",
					 EXT4_I(inode)->i_file_acl);
1411
			error = -EFSCORRUPTED;
1412 1413 1414 1415 1416 1417
			goto cleanup;
		}
		base = BHDR(bh);
		first = BFIRST(bh);
		end = bh->b_data + bh->b_size;
		min_offs = end - base;
1418
		free = ext4_xattr_free_space(first, &min_offs, base, NULL);
1419
		if (free < isize_diff) {
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
			if (!tried_min_extra_isize && s_min_extra_isize) {
				tried_min_extra_isize++;
				new_extra_isize = s_min_extra_isize;
				brelse(bh);
				goto retry;
			}
			error = -1;
			goto cleanup;
		}
	} else {
		free = inode->i_sb->s_blocksize;
	}

1433
	while (isize_diff > 0) {
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
		size_t offs, size, entry_size;
		struct ext4_xattr_entry *small_entry = NULL;
		struct ext4_xattr_info i = {
			.value = NULL,
			.value_len = 0,
		};
		unsigned int total_size;  /* EA entry size + value size */
		unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
		unsigned int min_total_size = ~0U;

		is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
		bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
		if (!is || !bs) {
			error = -ENOMEM;
			goto cleanup;
		}

		is->s.not_found = -ENODATA;
		bs->s.not_found = -ENODATA;
		is->iloc.bh = NULL;
		bs->bh = NULL;

		last = IFIRST(header);
		/* Find the entry best suited to be pushed into EA block */
		entry = NULL;
		for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
			total_size =
			EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
					EXT4_XATTR_LEN(last->e_name_len);
			if (total_size <= free && total_size < min_total_size) {
1464
				if (total_size < isize_diff) {
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
					small_entry = last;
				} else {
					entry = last;
					min_total_size = total_size;
				}
			}
		}

		if (entry == NULL) {
			if (small_entry) {
				entry = small_entry;
			} else {
				if (!tried_min_extra_isize &&
				    s_min_extra_isize) {
					tried_min_extra_isize++;
					new_extra_isize = s_min_extra_isize;
D
Dave Jones 已提交
1481 1482
					kfree(is); is = NULL;
					kfree(bs); bs = NULL;
1483
					brelse(bh);
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
					goto retry;
				}
				error = -1;
				goto cleanup;
			}
		}
		offs = le16_to_cpu(entry->e_value_offs);
		size = le32_to_cpu(entry->e_value_size);
		entry_size = EXT4_XATTR_LEN(entry->e_name_len);
		i.name_index = entry->e_name_index,
		buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
		b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
		if (!buffer || !b_entry_name) {
			error = -ENOMEM;
			goto cleanup;
		}
		/* Save the entry name and the entry value */
		memcpy(buffer, (void *)IFIRST(header) + offs,
		       EXT4_XATTR_SIZE(size));
		memcpy(b_entry_name, entry->e_name, entry->e_name_len);
		b_entry_name[entry->e_name_len] = '\0';
		i.name = b_entry_name;

		error = ext4_get_inode_loc(inode, &is->iloc);
		if (error)
			goto cleanup;

		error = ext4_xattr_ibody_find(inode, &i, is);
		if (error)
			goto cleanup;

		/* Remove the chosen entry from the inode */
		error = ext4_xattr_ibody_set(handle, inode, &i, is);
1517 1518
		if (error)
			goto cleanup;
1519 1520

		entry = IFIRST(header);
1521 1522
		if (entry_size + EXT4_XATTR_SIZE(size) >= isize_diff)
			shift_bytes = isize_diff;
1523 1524 1525
		else
			shift_bytes = entry_size + size;
		/* Adjust the offsets and shift the remaining entries ahead */
1526 1527 1528
		ext4_xattr_shift_entries(entry, -shift_bytes,
			(void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE +
			EXT4_I(inode)->i_extra_isize + shift_bytes,
1529 1530 1531
			(void *)header, total_ino - entry_size,
			inode->i_sb->s_blocksize);

1532 1533
		isize_diff -= shift_bytes;
		EXT4_I(inode)->i_extra_isize += shift_bytes;
1534 1535 1536

		i.name = b_entry_name;
		i.value = buffer;
A
Aneesh Kumar K.V 已提交
1537
		i.value_len = size;
1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
		error = ext4_xattr_block_find(inode, &i, bs);
		if (error)
			goto cleanup;

		/* Add entry which was removed from the inode into the block */
		error = ext4_xattr_block_set(handle, inode, &i, bs);
		if (error)
			goto cleanup;
		kfree(b_entry_name);
		kfree(buffer);
1548 1549
		b_entry_name = NULL;
		buffer = NULL;
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
		brelse(is->iloc.bh);
		kfree(is);
		kfree(bs);
	}
	brelse(bh);
	up_write(&EXT4_I(inode)->xattr_sem);
	return 0;

cleanup:
	kfree(b_entry_name);
	kfree(buffer);
	if (is)
		brelse(is->iloc.bh);
	kfree(is);
	kfree(bs);
	brelse(bh);
	up_write(&EXT4_I(inode)->xattr_sem);
	return error;
}



1572
/*
1573
 * ext4_xattr_delete_inode()
1574 1575 1576 1577 1578 1579
 *
 * Free extended attribute resources associated with this inode. This
 * is called immediately before an inode is freed. We have exclusive
 * access to the inode.
 */
void
1580
ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
1581 1582 1583
{
	struct buffer_head *bh = NULL;

1584
	if (!EXT4_I(inode)->i_file_acl)
1585
		goto cleanup;
1586
	bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1587
	if (!bh) {
1588 1589
		EXT4_ERROR_INODE(inode, "block %llu read error",
				 EXT4_I(inode)->i_file_acl);
1590 1591
		goto cleanup;
	}
1592
	if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1593
	    BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1594 1595
		EXT4_ERROR_INODE(inode, "bad block %llu",
				 EXT4_I(inode)->i_file_acl);
1596 1597
		goto cleanup;
	}
1598 1599
	ext4_xattr_release_block(handle, inode, bh);
	EXT4_I(inode)->i_file_acl = 0;
1600 1601 1602 1603 1604 1605

cleanup:
	brelse(bh);
}

/*
1606
 * ext4_xattr_cache_insert()
1607 1608 1609 1610 1611 1612 1613
 *
 * Create a new entry in the extended attribute cache, and insert
 * it unless such an entry is already in the cache.
 *
 * Returns 0, or a negative error number on failure.
 */
static void
J
Jan Kara 已提交
1614
ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
1615
{
1616 1617 1618 1619
	struct ext4_xattr_header *header = BHDR(bh);
	__u32 hash = le32_to_cpu(header->h_hash);
	int reusable = le32_to_cpu(header->h_refcount) <
		       EXT4_XATTR_REFCOUNT_MAX;
1620 1621
	int error;

J
Jan Kara 已提交
1622
	error = mb_cache_entry_create(ext4_mb_cache, GFP_NOFS, hash,
1623
				      bh->b_blocknr, reusable);
1624
	if (error) {
J
Jan Kara 已提交
1625
		if (error == -EBUSY)
1626
			ea_bdebug(bh, "already in cache");
J
Jan Kara 已提交
1627
	} else
1628 1629 1630 1631
		ea_bdebug(bh, "inserting [%x]", (int)hash);
}

/*
1632
 * ext4_xattr_cmp()
1633 1634 1635 1636 1637 1638 1639
 *
 * Compare two extended attribute blocks for equality.
 *
 * Returns 0 if the blocks are equal, 1 if they differ, and
 * a negative error number on errors.
 */
static int
1640 1641
ext4_xattr_cmp(struct ext4_xattr_header *header1,
	       struct ext4_xattr_header *header2)
1642
{
1643
	struct ext4_xattr_entry *entry1, *entry2;
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656

	entry1 = ENTRY(header1+1);
	entry2 = ENTRY(header2+1);
	while (!IS_LAST_ENTRY(entry1)) {
		if (IS_LAST_ENTRY(entry2))
			return 1;
		if (entry1->e_hash != entry2->e_hash ||
		    entry1->e_name_index != entry2->e_name_index ||
		    entry1->e_name_len != entry2->e_name_len ||
		    entry1->e_value_size != entry2->e_value_size ||
		    memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
			return 1;
		if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
1657
			return -EFSCORRUPTED;
1658 1659 1660 1661 1662
		if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
			   (char *)header2 + le16_to_cpu(entry2->e_value_offs),
			   le32_to_cpu(entry1->e_value_size)))
			return 1;

1663 1664
		entry1 = EXT4_XATTR_NEXT(entry1);
		entry2 = EXT4_XATTR_NEXT(entry2);
1665 1666 1667 1668 1669 1670 1671
	}
	if (!IS_LAST_ENTRY(entry2))
		return 1;
	return 0;
}

/*
1672
 * ext4_xattr_cache_find()
1673 1674 1675 1676 1677 1678 1679
 *
 * Find an identical extended attribute block.
 *
 * Returns a pointer to the block found, or NULL if such a block was
 * not found or an error occurred.
 */
static struct buffer_head *
1680
ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
J
Jan Kara 已提交
1681
		      struct mb_cache_entry **pce)
1682 1683
{
	__u32 hash = le32_to_cpu(header->h_hash);
J
Jan Kara 已提交
1684 1685
	struct mb_cache_entry *ce;
	struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
1686 1687 1688 1689

	if (!header->h_hash)
		return NULL;  /* never share */
	ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
J
Jan Kara 已提交
1690
	ce = mb_cache_entry_find_first(ext4_mb_cache, hash);
1691 1692 1693 1694 1695
	while (ce) {
		struct buffer_head *bh;

		bh = sb_bread(inode->i_sb, ce->e_block);
		if (!bh) {
1696 1697
			EXT4_ERROR_INODE(inode, "block %lu read error",
					 (unsigned long) ce->e_block);
1698
		} else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
1699 1700 1701 1702
			*pce = ce;
			return bh;
		}
		brelse(bh);
J
Jan Kara 已提交
1703
		ce = mb_cache_entry_find_next(ext4_mb_cache, ce);
1704 1705 1706 1707 1708 1709 1710 1711
	}
	return NULL;
}

#define NAME_HASH_SHIFT 5
#define VALUE_HASH_SHIFT 16

/*
1712
 * ext4_xattr_hash_entry()
1713 1714 1715
 *
 * Compute the hash of an extended attribute.
 */
1716 1717
static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
					 struct ext4_xattr_entry *entry)
1718 1719 1720 1721 1722
{
	__u32 hash = 0;
	char *name = entry->e_name;
	int n;

1723
	for (n = 0; n < entry->e_name_len; n++) {
1724 1725 1726 1727 1728 1729 1730 1731 1732
		hash = (hash << NAME_HASH_SHIFT) ^
		       (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
		       *name++;
	}

	if (entry->e_value_block == 0 && entry->e_value_size != 0) {
		__le32 *value = (__le32 *)((char *)header +
			le16_to_cpu(entry->e_value_offs));
		for (n = (le32_to_cpu(entry->e_value_size) +
1733
		     EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747
			hash = (hash << VALUE_HASH_SHIFT) ^
			       (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
			       le32_to_cpu(*value++);
		}
	}
	entry->e_hash = cpu_to_le32(hash);
}

#undef NAME_HASH_SHIFT
#undef VALUE_HASH_SHIFT

#define BLOCK_HASH_SHIFT 16

/*
1748
 * ext4_xattr_rehash()
1749 1750 1751
 *
 * Re-compute the extended attribute hash value after an entry has changed.
 */
1752 1753
static void ext4_xattr_rehash(struct ext4_xattr_header *header,
			      struct ext4_xattr_entry *entry)
1754
{
1755
	struct ext4_xattr_entry *here;
1756 1757
	__u32 hash = 0;

1758
	ext4_xattr_hash_entry(header, entry);
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
	here = ENTRY(header+1);
	while (!IS_LAST_ENTRY(here)) {
		if (!here->e_hash) {
			/* Block is not shared if an entry's hash value == 0 */
			hash = 0;
			break;
		}
		hash = (hash << BLOCK_HASH_SHIFT) ^
		       (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
		       le32_to_cpu(here->e_hash);
1769
		here = EXT4_XATTR_NEXT(here);
1770 1771 1772 1773 1774 1775
	}
	header->h_hash = cpu_to_le32(hash);
}

#undef BLOCK_HASH_SHIFT

1776 1777
#define	HASH_BUCKET_BITS	10

J
Jan Kara 已提交
1778
struct mb_cache *
J
Jan Kara 已提交
1779
ext4_xattr_create_cache(void)
1780
{
J
Jan Kara 已提交
1781
	return mb_cache_create(HASH_BUCKET_BITS);
1782 1783
}

J
Jan Kara 已提交
1784
void ext4_xattr_destroy_cache(struct mb_cache *cache)
1785
{
1786
	if (cache)
J
Jan Kara 已提交
1787
		mb_cache_destroy(cache);
1788
}
1789