3236 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * linux/fs/ext4/xattr.c4 *5 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>6 *7 * Fix by Harrison Xing <harrison@mountainviewdata.com>.8 * Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.9 * Extended attributes for symlinks and special files added per10 * suggestion of Luka Renko <luka.renko@hermes.si>.11 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,12 * Red Hat Inc.13 * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz14 * and Andreas Gruenbacher <agruen@suse.de>.15 */16 17/*18 * Extended attributes are stored directly in inodes (on file systems with19 * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl20 * field contains the block number if an inode uses an additional block. All21 * attributes must fit in the inode and one additional block. Blocks that22 * contain the identical set of attributes may be shared among several inodes.23 * Identical blocks are detected by keeping a cache of blocks that have24 * recently been accessed.25 *26 * The attributes in inodes and on blocks have a different header; the entries27 * are stored in the same format:28 *29 * +------------------+30 * | header |31 * | entry 1 | |32 * | entry 2 | | growing downwards33 * | entry 3 | v34 * | four null bytes |35 * | . . . |36 * | value 1 | ^37 * | value 3 | | growing upwards38 * | value 2 | |39 * +------------------+40 *41 * The header is followed by multiple entry descriptors. In disk blocks, the42 * entry descriptors are kept sorted. In inodes, they are unsorted. The43 * attribute values are aligned to the end of the block in no specific order.44 *45 * Locking strategy46 * ----------------47 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.48 * EA blocks are only changed if they are exclusive to an inode, so49 * holding xattr_sem also means that nothing but the EA block's reference50 * count can change. Multiple writers to the same block are synchronized51 * by the buffer lock.52 */53 54#include <linux/init.h>55#include <linux/fs.h>56#include <linux/slab.h>57#include <linux/mbcache.h>58#include <linux/quotaops.h>59#include <linux/iversion.h>60#include "ext4_jbd2.h"61#include "ext4.h"62#include "xattr.h"63#include "acl.h"64 65#ifdef EXT4_XATTR_DEBUG66# define ea_idebug(inode, fmt, ...) \67 printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \68 inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)69# define ea_bdebug(bh, fmt, ...) \70 printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \71 bh->b_bdev, (unsigned long)bh->b_blocknr, ##__VA_ARGS__)72#else73# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)74# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)75#endif76 77static void ext4_xattr_block_cache_insert(struct mb_cache *,78 struct buffer_head *);79static struct buffer_head *80ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,81 struct mb_cache_entry **);82static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,83 size_t value_count);84static __le32 ext4_xattr_hash_entry_signed(char *name, size_t name_len, __le32 *value,85 size_t value_count);86static void ext4_xattr_rehash(struct ext4_xattr_header *);87 88static const struct xattr_handler * const ext4_xattr_handler_map[] = {89 [EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,90#ifdef CONFIG_EXT4_FS_POSIX_ACL91 [EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &nop_posix_acl_access,92 [EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &nop_posix_acl_default,93#endif94 [EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,95#ifdef CONFIG_EXT4_FS_SECURITY96 [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,97#endif98 [EXT4_XATTR_INDEX_HURD] = &ext4_xattr_hurd_handler,99};100 101const struct xattr_handler * const ext4_xattr_handlers[] = {102 &ext4_xattr_user_handler,103 &ext4_xattr_trusted_handler,104#ifdef CONFIG_EXT4_FS_SECURITY105 &ext4_xattr_security_handler,106#endif107 &ext4_xattr_hurd_handler,108 NULL109};110 111#define EA_BLOCK_CACHE(inode) (((struct ext4_sb_info *) \112 inode->i_sb->s_fs_info)->s_ea_block_cache)113 114#define EA_INODE_CACHE(inode) (((struct ext4_sb_info *) \115 inode->i_sb->s_fs_info)->s_ea_inode_cache)116 117static int118ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,119 struct inode *inode);120 121#ifdef CONFIG_LOCKDEP122void ext4_xattr_inode_set_class(struct inode *ea_inode)123{124 struct ext4_inode_info *ei = EXT4_I(ea_inode);125 126 lockdep_set_subclass(&ea_inode->i_rwsem, 1);127 (void) ei; /* shut up clang warning if !CONFIG_LOCKDEP */128 lockdep_set_subclass(&ei->i_data_sem, I_DATA_SEM_EA);129}130#endif131 132static __le32 ext4_xattr_block_csum(struct inode *inode,133 sector_t block_nr,134 struct ext4_xattr_header *hdr)135{136 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);137 __u32 csum;138 __le64 dsk_block_nr = cpu_to_le64(block_nr);139 __u32 dummy_csum = 0;140 int offset = offsetof(struct ext4_xattr_header, h_checksum);141 142 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,143 sizeof(dsk_block_nr));144 csum = ext4_chksum(sbi, csum, (__u8 *)hdr, offset);145 csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));146 offset += sizeof(dummy_csum);147 csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset,148 EXT4_BLOCK_SIZE(inode->i_sb) - offset);149 150 return cpu_to_le32(csum);151}152 153static int ext4_xattr_block_csum_verify(struct inode *inode,154 struct buffer_head *bh)155{156 struct ext4_xattr_header *hdr = BHDR(bh);157 int ret = 1;158 159 if (ext4_has_metadata_csum(inode->i_sb)) {160 lock_buffer(bh);161 ret = (hdr->h_checksum == ext4_xattr_block_csum(inode,162 bh->b_blocknr, hdr));163 unlock_buffer(bh);164 }165 return ret;166}167 168static void ext4_xattr_block_csum_set(struct inode *inode,169 struct buffer_head *bh)170{171 if (ext4_has_metadata_csum(inode->i_sb))172 BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode,173 bh->b_blocknr, BHDR(bh));174}175 176static inline const char *ext4_xattr_prefix(int name_index,177 struct dentry *dentry)178{179 const struct xattr_handler *handler = NULL;180 181 if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))182 handler = ext4_xattr_handler_map[name_index];183 184 if (!xattr_handler_can_list(handler, dentry))185 return NULL;186 187 return xattr_prefix(handler);188}189 190static int191check_xattrs(struct inode *inode, struct buffer_head *bh,192 struct ext4_xattr_entry *entry, void *end, void *value_start,193 const char *function, unsigned int line)194{195 struct ext4_xattr_entry *e = entry;196 int err = -EFSCORRUPTED;197 char *err_str;198 199 if (bh) {200 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||201 BHDR(bh)->h_blocks != cpu_to_le32(1)) {202 err_str = "invalid header";203 goto errout;204 }205 if (buffer_verified(bh))206 return 0;207 if (!ext4_xattr_block_csum_verify(inode, bh)) {208 err = -EFSBADCRC;209 err_str = "invalid checksum";210 goto errout;211 }212 } else {213 struct ext4_xattr_ibody_header *header = value_start;214 215 header -= 1;216 if (end - (void *)header < sizeof(*header) + sizeof(u32)) {217 err_str = "in-inode xattr block too small";218 goto errout;219 }220 if (header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {221 err_str = "bad magic number in in-inode xattr";222 goto errout;223 }224 }225 226 /* Find the end of the names list */227 while (!IS_LAST_ENTRY(e)) {228 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);229 if ((void *)next >= end) {230 err_str = "e_name out of bounds";231 goto errout;232 }233 if (strnlen(e->e_name, e->e_name_len) != e->e_name_len) {234 err_str = "bad e_name length";235 goto errout;236 }237 e = next;238 }239 240 /* Check the values */241 while (!IS_LAST_ENTRY(entry)) {242 u32 size = le32_to_cpu(entry->e_value_size);243 unsigned long ea_ino = le32_to_cpu(entry->e_value_inum);244 245 if (!ext4_has_feature_ea_inode(inode->i_sb) && ea_ino) {246 err_str = "ea_inode specified without ea_inode feature enabled";247 goto errout;248 }249 if (ea_ino && ((ea_ino == EXT4_ROOT_INO) ||250 !ext4_valid_inum(inode->i_sb, ea_ino))) {251 err_str = "invalid ea_ino";252 goto errout;253 }254 if (size > EXT4_XATTR_SIZE_MAX) {255 err_str = "e_value size too large";256 goto errout;257 }258 259 if (size != 0 && entry->e_value_inum == 0) {260 u16 offs = le16_to_cpu(entry->e_value_offs);261 void *value;262 263 /*264 * The value cannot overlap the names, and the value265 * with padding cannot extend beyond 'end'. Check both266 * the padded and unpadded sizes, since the size may267 * overflow to 0 when adding padding.268 */269 if (offs > end - value_start) {270 err_str = "e_value out of bounds";271 goto errout;272 }273 value = value_start + offs;274 if (value < (void *)e + sizeof(u32) ||275 size > end - value ||276 EXT4_XATTR_SIZE(size) > end - value) {277 err_str = "overlapping e_value ";278 goto errout;279 }280 }281 entry = EXT4_XATTR_NEXT(entry);282 }283 if (bh)284 set_buffer_verified(bh);285 return 0;286 287errout:288 if (bh)289 __ext4_error_inode(inode, function, line, 0, -err,290 "corrupted xattr block %llu: %s",291 (unsigned long long) bh->b_blocknr,292 err_str);293 else294 __ext4_error_inode(inode, function, line, 0, -err,295 "corrupted in-inode xattr: %s", err_str);296 return err;297}298 299static inline int300__ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh,301 const char *function, unsigned int line)302{303 return check_xattrs(inode, bh, BFIRST(bh), bh->b_data + bh->b_size,304 bh->b_data, function, line);305}306 307#define ext4_xattr_check_block(inode, bh) \308 __ext4_xattr_check_block((inode), (bh), __func__, __LINE__)309 310 311static inline int312__xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,313 void *end, const char *function, unsigned int line)314{315 return check_xattrs(inode, NULL, IFIRST(header), end, IFIRST(header),316 function, line);317}318 319#define xattr_check_inode(inode, header, end) \320 __xattr_check_inode((inode), (header), (end), __func__, __LINE__)321 322static int323xattr_find_entry(struct inode *inode, struct ext4_xattr_entry **pentry,324 void *end, int name_index, const char *name, int sorted)325{326 struct ext4_xattr_entry *entry, *next;327 size_t name_len;328 int cmp = 1;329 330 if (name == NULL)331 return -EINVAL;332 name_len = strlen(name);333 for (entry = *pentry; !IS_LAST_ENTRY(entry); entry = next) {334 next = EXT4_XATTR_NEXT(entry);335 if ((void *) next >= end) {336 EXT4_ERROR_INODE(inode, "corrupted xattr entries");337 return -EFSCORRUPTED;338 }339 cmp = name_index - entry->e_name_index;340 if (!cmp)341 cmp = name_len - entry->e_name_len;342 if (!cmp)343 cmp = memcmp(name, entry->e_name, name_len);344 if (cmp <= 0 && (sorted || cmp == 0))345 break;346 }347 *pentry = entry;348 return cmp ? -ENODATA : 0;349}350 351static u32352ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)353{354 return ext4_chksum(sbi, sbi->s_csum_seed, buffer, size);355}356 357static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)358{359 return ((u64) inode_get_ctime_sec(ea_inode) << 32) |360 (u32) inode_peek_iversion_raw(ea_inode);361}362 363static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)364{365 inode_set_ctime(ea_inode, (u32)(ref_count >> 32), 0);366 inode_set_iversion_raw(ea_inode, ref_count & 0xffffffff);367}368 369static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)370{371 return (u32) inode_get_atime_sec(ea_inode);372}373 374static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)375{376 inode_set_atime(ea_inode, hash, 0);377}378 379/*380 * Read the EA value from an inode.381 */382static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t size)383{384 int blocksize = 1 << ea_inode->i_blkbits;385 int bh_count = (size + blocksize - 1) >> ea_inode->i_blkbits;386 int tail_size = (size % blocksize) ?: blocksize;387 struct buffer_head *bhs_inline[8];388 struct buffer_head **bhs = bhs_inline;389 int i, ret;390 391 if (bh_count > ARRAY_SIZE(bhs_inline)) {392 bhs = kmalloc_array(bh_count, sizeof(*bhs), GFP_NOFS);393 if (!bhs)394 return -ENOMEM;395 }396 397 ret = ext4_bread_batch(ea_inode, 0 /* block */, bh_count,398 true /* wait */, bhs);399 if (ret)400 goto free_bhs;401 402 for (i = 0; i < bh_count; i++) {403 /* There shouldn't be any holes in ea_inode. */404 if (!bhs[i]) {405 ret = -EFSCORRUPTED;406 goto put_bhs;407 }408 memcpy((char *)buf + blocksize * i, bhs[i]->b_data,409 i < bh_count - 1 ? blocksize : tail_size);410 }411 ret = 0;412put_bhs:413 for (i = 0; i < bh_count; i++)414 brelse(bhs[i]);415free_bhs:416 if (bhs != bhs_inline)417 kfree(bhs);418 return ret;419}420 421#define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode_get_mtime_sec(inode)))422 423static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,424 u32 ea_inode_hash, struct inode **ea_inode)425{426 struct inode *inode;427 int err;428 429 /*430 * We have to check for this corruption early as otherwise431 * iget_locked() could wait indefinitely for the state of our432 * parent inode.433 */434 if (parent->i_ino == ea_ino) {435 ext4_error(parent->i_sb,436 "Parent and EA inode have the same ino %lu", ea_ino);437 return -EFSCORRUPTED;438 }439 440 inode = ext4_iget(parent->i_sb, ea_ino, EXT4_IGET_EA_INODE);441 if (IS_ERR(inode)) {442 err = PTR_ERR(inode);443 ext4_error(parent->i_sb,444 "error while reading EA inode %lu err=%d", ea_ino,445 err);446 return err;447 }448 ext4_xattr_inode_set_class(inode);449 450 /*451 * Check whether this is an old Lustre-style xattr inode. Lustre452 * implementation does not have hash validation, rather it has a453 * backpointer from ea_inode to the parent inode.454 */455 if (ea_inode_hash != ext4_xattr_inode_get_hash(inode) &&456 EXT4_XATTR_INODE_GET_PARENT(inode) == parent->i_ino &&457 inode->i_generation == parent->i_generation) {458 ext4_set_inode_state(inode, EXT4_STATE_LUSTRE_EA_INODE);459 ext4_xattr_inode_set_ref(inode, 1);460 } else {461 inode_lock_nested(inode, I_MUTEX_XATTR);462 inode->i_flags |= S_NOQUOTA;463 inode_unlock(inode);464 }465 466 *ea_inode = inode;467 return 0;468}469 470/* Remove entry from mbcache when EA inode is getting evicted */471void ext4_evict_ea_inode(struct inode *inode)472{473 struct mb_cache_entry *oe;474 475 if (!EA_INODE_CACHE(inode))476 return;477 /* Wait for entry to get unused so that we can remove it */478 while ((oe = mb_cache_entry_delete_or_get(EA_INODE_CACHE(inode),479 ext4_xattr_inode_get_hash(inode), inode->i_ino))) {480 mb_cache_entry_wait_unused(oe);481 mb_cache_entry_put(EA_INODE_CACHE(inode), oe);482 }483}484 485static int486ext4_xattr_inode_verify_hashes(struct inode *ea_inode,487 struct ext4_xattr_entry *entry, void *buffer,488 size_t size)489{490 u32 hash;491 492 /* Verify stored hash matches calculated hash. */493 hash = ext4_xattr_inode_hash(EXT4_SB(ea_inode->i_sb), buffer, size);494 if (hash != ext4_xattr_inode_get_hash(ea_inode))495 return -EFSCORRUPTED;496 497 if (entry) {498 __le32 e_hash, tmp_data;499 500 /* Verify entry hash. */501 tmp_data = cpu_to_le32(hash);502 e_hash = ext4_xattr_hash_entry(entry->e_name, entry->e_name_len,503 &tmp_data, 1);504 /* All good? */505 if (e_hash == entry->e_hash)506 return 0;507 508 /*509 * Not good. Maybe the entry hash was calculated510 * using the buggy signed char version?511 */512 e_hash = ext4_xattr_hash_entry_signed(entry->e_name, entry->e_name_len,513 &tmp_data, 1);514 /* Still no match - bad */515 if (e_hash != entry->e_hash)516 return -EFSCORRUPTED;517 518 /* Let people know about old hash */519 pr_warn_once("ext4: filesystem with signed xattr name hash");520 }521 return 0;522}523 524/*525 * Read xattr value from the EA inode.526 */527static int528ext4_xattr_inode_get(struct inode *inode, struct ext4_xattr_entry *entry,529 void *buffer, size_t size)530{531 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);532 struct inode *ea_inode;533 int err;534 535 err = ext4_xattr_inode_iget(inode, le32_to_cpu(entry->e_value_inum),536 le32_to_cpu(entry->e_hash), &ea_inode);537 if (err) {538 ea_inode = NULL;539 goto out;540 }541 542 if (i_size_read(ea_inode) != size) {543 ext4_warning_inode(ea_inode,544 "ea_inode file size=%llu entry size=%zu",545 i_size_read(ea_inode), size);546 err = -EFSCORRUPTED;547 goto out;548 }549 550 err = ext4_xattr_inode_read(ea_inode, buffer, size);551 if (err)552 goto out;553 554 if (!ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE)) {555 err = ext4_xattr_inode_verify_hashes(ea_inode, entry, buffer,556 size);557 if (err) {558 ext4_warning_inode(ea_inode,559 "EA inode hash validation failed");560 goto out;561 }562 563 if (ea_inode_cache)564 mb_cache_entry_create(ea_inode_cache, GFP_NOFS,565 ext4_xattr_inode_get_hash(ea_inode),566 ea_inode->i_ino, true /* reusable */);567 }568out:569 iput(ea_inode);570 return err;571}572 573static int574ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,575 void *buffer, size_t buffer_size)576{577 struct buffer_head *bh = NULL;578 struct ext4_xattr_entry *entry;579 size_t size;580 void *end;581 int error;582 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);583 584 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",585 name_index, name, buffer, (long)buffer_size);586 587 if (!EXT4_I(inode)->i_file_acl)588 return -ENODATA;589 ea_idebug(inode, "reading block %llu",590 (unsigned long long)EXT4_I(inode)->i_file_acl);591 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);592 if (IS_ERR(bh))593 return PTR_ERR(bh);594 ea_bdebug(bh, "b_count=%d, refcount=%d",595 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));596 error = ext4_xattr_check_block(inode, bh);597 if (error)598 goto cleanup;599 ext4_xattr_block_cache_insert(ea_block_cache, bh);600 entry = BFIRST(bh);601 end = bh->b_data + bh->b_size;602 error = xattr_find_entry(inode, &entry, end, name_index, name, 1);603 if (error)604 goto cleanup;605 size = le32_to_cpu(entry->e_value_size);606 error = -ERANGE;607 if (unlikely(size > EXT4_XATTR_SIZE_MAX))608 goto cleanup;609 if (buffer) {610 if (size > buffer_size)611 goto cleanup;612 if (entry->e_value_inum) {613 error = ext4_xattr_inode_get(inode, entry, buffer,614 size);615 if (error)616 goto cleanup;617 } else {618 u16 offset = le16_to_cpu(entry->e_value_offs);619 void *p = bh->b_data + offset;620 621 if (unlikely(p + size > end))622 goto cleanup;623 memcpy(buffer, p, size);624 }625 }626 error = size;627 628cleanup:629 brelse(bh);630 return error;631}632 633int634ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,635 void *buffer, size_t buffer_size)636{637 struct ext4_xattr_ibody_header *header;638 struct ext4_xattr_entry *entry;639 struct ext4_inode *raw_inode;640 struct ext4_iloc iloc;641 size_t size;642 void *end;643 int error;644 645 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))646 return -ENODATA;647 error = ext4_get_inode_loc(inode, &iloc);648 if (error)649 return error;650 raw_inode = ext4_raw_inode(&iloc);651 header = IHDR(inode, raw_inode);652 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;653 error = xattr_check_inode(inode, header, end);654 if (error)655 goto cleanup;656 entry = IFIRST(header);657 error = xattr_find_entry(inode, &entry, end, name_index, name, 0);658 if (error)659 goto cleanup;660 size = le32_to_cpu(entry->e_value_size);661 error = -ERANGE;662 if (unlikely(size > EXT4_XATTR_SIZE_MAX))663 goto cleanup;664 if (buffer) {665 if (size > buffer_size)666 goto cleanup;667 if (entry->e_value_inum) {668 error = ext4_xattr_inode_get(inode, entry, buffer,669 size);670 if (error)671 goto cleanup;672 } else {673 u16 offset = le16_to_cpu(entry->e_value_offs);674 void *p = (void *)IFIRST(header) + offset;675 676 if (unlikely(p + size > end))677 goto cleanup;678 memcpy(buffer, p, size);679 }680 }681 error = size;682 683cleanup:684 brelse(iloc.bh);685 return error;686}687 688/*689 * ext4_xattr_get()690 *691 * Copy an extended attribute into the buffer692 * provided, or compute the buffer size required.693 * Buffer is NULL to compute the size of the buffer required.694 *695 * Returns a negative error number on failure, or the number of bytes696 * used / required on success.697 */698int699ext4_xattr_get(struct inode *inode, int name_index, const char *name,700 void *buffer, size_t buffer_size)701{702 int error;703 704 if (unlikely(ext4_forced_shutdown(inode->i_sb)))705 return -EIO;706 707 if (strlen(name) > 255)708 return -ERANGE;709 710 down_read(&EXT4_I(inode)->xattr_sem);711 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,712 buffer_size);713 if (error == -ENODATA)714 error = ext4_xattr_block_get(inode, name_index, name, buffer,715 buffer_size);716 up_read(&EXT4_I(inode)->xattr_sem);717 return error;718}719 720static int721ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,722 char *buffer, size_t buffer_size)723{724 size_t rest = buffer_size;725 726 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {727 const char *prefix;728 729 prefix = ext4_xattr_prefix(entry->e_name_index, dentry);730 if (prefix) {731 size_t prefix_len = strlen(prefix);732 size_t size = prefix_len + entry->e_name_len + 1;733 734 if (buffer) {735 if (size > rest)736 return -ERANGE;737 memcpy(buffer, prefix, prefix_len);738 buffer += prefix_len;739 memcpy(buffer, entry->e_name, entry->e_name_len);740 buffer += entry->e_name_len;741 *buffer++ = 0;742 }743 rest -= size;744 }745 }746 return buffer_size - rest; /* total size */747}748 749static int750ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)751{752 struct inode *inode = d_inode(dentry);753 struct buffer_head *bh = NULL;754 int error;755 756 ea_idebug(inode, "buffer=%p, buffer_size=%ld",757 buffer, (long)buffer_size);758 759 if (!EXT4_I(inode)->i_file_acl)760 return 0;761 ea_idebug(inode, "reading block %llu",762 (unsigned long long)EXT4_I(inode)->i_file_acl);763 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);764 if (IS_ERR(bh))765 return PTR_ERR(bh);766 ea_bdebug(bh, "b_count=%d, refcount=%d",767 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));768 error = ext4_xattr_check_block(inode, bh);769 if (error)770 goto cleanup;771 ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);772 error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer,773 buffer_size);774cleanup:775 brelse(bh);776 return error;777}778 779static int780ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)781{782 struct inode *inode = d_inode(dentry);783 struct ext4_xattr_ibody_header *header;784 struct ext4_inode *raw_inode;785 struct ext4_iloc iloc;786 void *end;787 int error;788 789 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))790 return 0;791 error = ext4_get_inode_loc(inode, &iloc);792 if (error)793 return error;794 raw_inode = ext4_raw_inode(&iloc);795 header = IHDR(inode, raw_inode);796 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;797 error = xattr_check_inode(inode, header, end);798 if (error)799 goto cleanup;800 error = ext4_xattr_list_entries(dentry, IFIRST(header),801 buffer, buffer_size);802 803cleanup:804 brelse(iloc.bh);805 return error;806}807 808/*809 * Inode operation listxattr()810 *811 * d_inode(dentry)->i_rwsem: don't care812 *813 * Copy a list of attribute names into the buffer814 * provided, or compute the buffer size required.815 * Buffer is NULL to compute the size of the buffer required.816 *817 * Returns a negative error number on failure, or the number of bytes818 * used / required on success.819 */820ssize_t821ext4_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)822{823 int ret, ret2;824 825 down_read(&EXT4_I(d_inode(dentry))->xattr_sem);826 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);827 if (ret < 0)828 goto errout;829 if (buffer) {830 buffer += ret;831 buffer_size -= ret;832 }833 ret = ext4_xattr_block_list(dentry, buffer, buffer_size);834 if (ret < 0)835 goto errout;836 ret += ret2;837errout:838 up_read(&EXT4_I(d_inode(dentry))->xattr_sem);839 return ret;840}841 842/*843 * If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is844 * not set, set it.845 */846static void ext4_xattr_update_super_block(handle_t *handle,847 struct super_block *sb)848{849 if (ext4_has_feature_xattr(sb))850 return;851 852 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");853 if (ext4_journal_get_write_access(handle, sb, EXT4_SB(sb)->s_sbh,854 EXT4_JTR_NONE) == 0) {855 lock_buffer(EXT4_SB(sb)->s_sbh);856 ext4_set_feature_xattr(sb);857 ext4_superblock_csum_set(sb);858 unlock_buffer(EXT4_SB(sb)->s_sbh);859 ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);860 }861}862 863int ext4_get_inode_usage(struct inode *inode, qsize_t *usage)864{865 struct ext4_iloc iloc = { .bh = NULL };866 struct buffer_head *bh = NULL;867 struct ext4_inode *raw_inode;868 struct ext4_xattr_ibody_header *header;869 struct ext4_xattr_entry *entry;870 qsize_t ea_inode_refs = 0;871 void *end;872 int ret;873 874 lockdep_assert_held_read(&EXT4_I(inode)->xattr_sem);875 876 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {877 ret = ext4_get_inode_loc(inode, &iloc);878 if (ret)879 goto out;880 raw_inode = ext4_raw_inode(&iloc);881 header = IHDR(inode, raw_inode);882 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;883 ret = xattr_check_inode(inode, header, end);884 if (ret)885 goto out;886 887 for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);888 entry = EXT4_XATTR_NEXT(entry))889 if (entry->e_value_inum)890 ea_inode_refs++;891 }892 893 if (EXT4_I(inode)->i_file_acl) {894 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);895 if (IS_ERR(bh)) {896 ret = PTR_ERR(bh);897 bh = NULL;898 goto out;899 }900 901 ret = ext4_xattr_check_block(inode, bh);902 if (ret)903 goto out;904 905 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);906 entry = EXT4_XATTR_NEXT(entry))907 if (entry->e_value_inum)908 ea_inode_refs++;909 }910 *usage = ea_inode_refs + 1;911 ret = 0;912out:913 brelse(iloc.bh);914 brelse(bh);915 return ret;916}917 918static inline size_t round_up_cluster(struct inode *inode, size_t length)919{920 struct super_block *sb = inode->i_sb;921 size_t cluster_size = 1 << (EXT4_SB(sb)->s_cluster_bits +922 inode->i_blkbits);923 size_t mask = ~(cluster_size - 1);924 925 return (length + cluster_size - 1) & mask;926}927 928static int ext4_xattr_inode_alloc_quota(struct inode *inode, size_t len)929{930 int err;931 932 err = dquot_alloc_inode(inode);933 if (err)934 return err;935 err = dquot_alloc_space_nodirty(inode, round_up_cluster(inode, len));936 if (err)937 dquot_free_inode(inode);938 return err;939}940 941static void ext4_xattr_inode_free_quota(struct inode *parent,942 struct inode *ea_inode,943 size_t len)944{945 if (ea_inode &&946 ext4_test_inode_state(ea_inode, EXT4_STATE_LUSTRE_EA_INODE))947 return;948 dquot_free_space_nodirty(parent, round_up_cluster(parent, len));949 dquot_free_inode(parent);950}951 952int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode,953 struct buffer_head *block_bh, size_t value_len,954 bool is_create)955{956 int credits;957 int blocks;958 959 /*960 * 1) Owner inode update961 * 2) Ref count update on old xattr block962 * 3) new xattr block963 * 4) block bitmap update for new xattr block964 * 5) group descriptor for new xattr block965 * 6) block bitmap update for old xattr block966 * 7) group descriptor for old block967 *968 * 6 & 7 can happen if we have two racing threads T_a and T_b969 * which are each trying to set an xattr on inodes I_a and I_b970 * which were both initially sharing an xattr block.971 */972 credits = 7;973 974 /* Quota updates. */975 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(sb);976 977 /*978 * In case of inline data, we may push out the data to a block,979 * so we need to reserve credits for this eventuality980 */981 if (inode && ext4_has_inline_data(inode))982 credits += ext4_writepage_trans_blocks(inode) + 1;983 984 /* We are done if ea_inode feature is not enabled. */985 if (!ext4_has_feature_ea_inode(sb))986 return credits;987 988 /* New ea_inode, inode map, block bitmap, group descriptor. */989 credits += 4;990 991 /* Data blocks. */992 blocks = (value_len + sb->s_blocksize - 1) >> sb->s_blocksize_bits;993 994 /* Indirection block or one level of extent tree. */995 blocks += 1;996 997 /* Block bitmap and group descriptor updates for each block. */998 credits += blocks * 2;999 1000 /* Blocks themselves. */1001 credits += blocks;1002 1003 if (!is_create) {1004 /* Dereference ea_inode holding old xattr value.1005 * Old ea_inode, inode map, block bitmap, group descriptor.1006 */1007 credits += 4;1008 1009 /* Data blocks for old ea_inode. */1010 blocks = XATTR_SIZE_MAX >> sb->s_blocksize_bits;1011 1012 /* Indirection block or one level of extent tree for old1013 * ea_inode.1014 */1015 blocks += 1;1016 1017 /* Block bitmap and group descriptor updates for each block. */1018 credits += blocks * 2;1019 }1020 1021 /* We may need to clone the existing xattr block in which case we need1022 * to increment ref counts for existing ea_inodes referenced by it.1023 */1024 if (block_bh) {1025 struct ext4_xattr_entry *entry = BFIRST(block_bh);1026 1027 for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry))1028 if (entry->e_value_inum)1029 /* Ref count update on ea_inode. */1030 credits += 1;1031 }1032 return credits;1033}1034 1035static int ext4_xattr_inode_update_ref(handle_t *handle, struct inode *ea_inode,1036 int ref_change)1037{1038 struct ext4_iloc iloc;1039 s64 ref_count;1040 int ret;1041 1042 inode_lock_nested(ea_inode, I_MUTEX_XATTR);1043 1044 ret = ext4_reserve_inode_write(handle, ea_inode, &iloc);1045 if (ret)1046 goto out;1047 1048 ref_count = ext4_xattr_inode_get_ref(ea_inode);1049 ref_count += ref_change;1050 ext4_xattr_inode_set_ref(ea_inode, ref_count);1051 1052 if (ref_change > 0) {1053 WARN_ONCE(ref_count <= 0, "EA inode %lu ref_count=%lld",1054 ea_inode->i_ino, ref_count);1055 1056 if (ref_count == 1) {1057 WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",1058 ea_inode->i_ino, ea_inode->i_nlink);1059 1060 set_nlink(ea_inode, 1);1061 ext4_orphan_del(handle, ea_inode);1062 }1063 } else {1064 WARN_ONCE(ref_count < 0, "EA inode %lu ref_count=%lld",1065 ea_inode->i_ino, ref_count);1066 1067 if (ref_count == 0) {1068 WARN_ONCE(ea_inode->i_nlink != 1,1069 "EA inode %lu i_nlink=%u",1070 ea_inode->i_ino, ea_inode->i_nlink);1071 1072 clear_nlink(ea_inode);1073 ext4_orphan_add(handle, ea_inode);1074 }1075 }1076 1077 ret = ext4_mark_iloc_dirty(handle, ea_inode, &iloc);1078 if (ret)1079 ext4_warning_inode(ea_inode,1080 "ext4_mark_iloc_dirty() failed ret=%d", ret);1081out:1082 inode_unlock(ea_inode);1083 return ret;1084}1085 1086static int ext4_xattr_inode_inc_ref(handle_t *handle, struct inode *ea_inode)1087{1088 return ext4_xattr_inode_update_ref(handle, ea_inode, 1);1089}1090 1091static int ext4_xattr_inode_dec_ref(handle_t *handle, struct inode *ea_inode)1092{1093 return ext4_xattr_inode_update_ref(handle, ea_inode, -1);1094}1095 1096static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent,1097 struct ext4_xattr_entry *first)1098{1099 struct inode *ea_inode;1100 struct ext4_xattr_entry *entry;1101 struct ext4_xattr_entry *failed_entry;1102 unsigned int ea_ino;1103 int err, saved_err;1104 1105 for (entry = first; !IS_LAST_ENTRY(entry);1106 entry = EXT4_XATTR_NEXT(entry)) {1107 if (!entry->e_value_inum)1108 continue;1109 ea_ino = le32_to_cpu(entry->e_value_inum);1110 err = ext4_xattr_inode_iget(parent, ea_ino,1111 le32_to_cpu(entry->e_hash),1112 &ea_inode);1113 if (err)1114 goto cleanup;1115 err = ext4_xattr_inode_inc_ref(handle, ea_inode);1116 if (err) {1117 ext4_warning_inode(ea_inode, "inc ref error %d", err);1118 iput(ea_inode);1119 goto cleanup;1120 }1121 iput(ea_inode);1122 }1123 return 0;1124 1125cleanup:1126 saved_err = err;1127 failed_entry = entry;1128 1129 for (entry = first; entry != failed_entry;1130 entry = EXT4_XATTR_NEXT(entry)) {1131 if (!entry->e_value_inum)1132 continue;1133 ea_ino = le32_to_cpu(entry->e_value_inum);1134 err = ext4_xattr_inode_iget(parent, ea_ino,1135 le32_to_cpu(entry->e_hash),1136 &ea_inode);1137 if (err) {1138 ext4_warning(parent->i_sb,1139 "cleanup ea_ino %u iget error %d", ea_ino,1140 err);1141 continue;1142 }1143 err = ext4_xattr_inode_dec_ref(handle, ea_inode);1144 if (err)1145 ext4_warning_inode(ea_inode, "cleanup dec ref error %d",1146 err);1147 iput(ea_inode);1148 }1149 return saved_err;1150}1151 1152static int ext4_xattr_restart_fn(handle_t *handle, struct inode *inode,1153 struct buffer_head *bh, bool block_csum, bool dirty)1154{1155 int error;1156 1157 if (bh && dirty) {1158 if (block_csum)1159 ext4_xattr_block_csum_set(inode, bh);1160 error = ext4_handle_dirty_metadata(handle, NULL, bh);1161 if (error) {1162 ext4_warning(inode->i_sb, "Handle metadata (error %d)",1163 error);1164 return error;1165 }1166 }1167 return 0;1168}1169 1170static void1171ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent,1172 struct buffer_head *bh,1173 struct ext4_xattr_entry *first, bool block_csum,1174 struct ext4_xattr_inode_array **ea_inode_array,1175 int extra_credits, bool skip_quota)1176{1177 struct inode *ea_inode;1178 struct ext4_xattr_entry *entry;1179 bool dirty = false;1180 unsigned int ea_ino;1181 int err;1182 int credits;1183 1184 /* One credit for dec ref on ea_inode, one for orphan list addition, */1185 credits = 2 + extra_credits;1186 1187 for (entry = first; !IS_LAST_ENTRY(entry);1188 entry = EXT4_XATTR_NEXT(entry)) {1189 if (!entry->e_value_inum)1190 continue;1191 ea_ino = le32_to_cpu(entry->e_value_inum);1192 err = ext4_xattr_inode_iget(parent, ea_ino,1193 le32_to_cpu(entry->e_hash),1194 &ea_inode);1195 if (err)1196 continue;1197 1198 err = ext4_expand_inode_array(ea_inode_array, ea_inode);1199 if (err) {1200 ext4_warning_inode(ea_inode,1201 "Expand inode array err=%d", err);1202 iput(ea_inode);1203 continue;1204 }1205 1206 err = ext4_journal_ensure_credits_fn(handle, credits, credits,1207 ext4_free_metadata_revoke_credits(parent->i_sb, 1),1208 ext4_xattr_restart_fn(handle, parent, bh, block_csum,1209 dirty));1210 if (err < 0) {1211 ext4_warning_inode(ea_inode, "Ensure credits err=%d",1212 err);1213 continue;1214 }1215 if (err > 0) {1216 err = ext4_journal_get_write_access(handle,1217 parent->i_sb, bh, EXT4_JTR_NONE);1218 if (err) {1219 ext4_warning_inode(ea_inode,1220 "Re-get write access err=%d",1221 err);1222 continue;1223 }1224 }1225 1226 err = ext4_xattr_inode_dec_ref(handle, ea_inode);1227 if (err) {1228 ext4_warning_inode(ea_inode, "ea_inode dec ref err=%d",1229 err);1230 continue;1231 }1232 1233 if (!skip_quota)1234 ext4_xattr_inode_free_quota(parent, ea_inode,1235 le32_to_cpu(entry->e_value_size));1236 1237 /*1238 * Forget about ea_inode within the same transaction that1239 * decrements the ref count. This avoids duplicate decrements in1240 * case the rest of the work spills over to subsequent1241 * transactions.1242 */1243 entry->e_value_inum = 0;1244 entry->e_value_size = 0;1245 1246 dirty = true;1247 }1248 1249 if (dirty) {1250 /*1251 * Note that we are deliberately skipping csum calculation for1252 * the final update because we do not expect any journal1253 * restarts until xattr block is freed.1254 */1255 1256 err = ext4_handle_dirty_metadata(handle, NULL, bh);1257 if (err)1258 ext4_warning_inode(parent,1259 "handle dirty metadata err=%d", err);1260 }1261}1262 1263/*1264 * Release the xattr block BH: If the reference count is > 1, decrement it;1265 * otherwise free the block.1266 */1267static void1268ext4_xattr_release_block(handle_t *handle, struct inode *inode,1269 struct buffer_head *bh,1270 struct ext4_xattr_inode_array **ea_inode_array,1271 int extra_credits)1272{1273 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);1274 u32 hash, ref;1275 int error = 0;1276 1277 BUFFER_TRACE(bh, "get_write_access");1278 error = ext4_journal_get_write_access(handle, inode->i_sb, bh,1279 EXT4_JTR_NONE);1280 if (error)1281 goto out;1282 1283retry_ref:1284 lock_buffer(bh);1285 hash = le32_to_cpu(BHDR(bh)->h_hash);1286 ref = le32_to_cpu(BHDR(bh)->h_refcount);1287 if (ref == 1) {1288 ea_bdebug(bh, "refcount now=0; freeing");1289 /*1290 * This must happen under buffer lock for1291 * ext4_xattr_block_set() to reliably detect freed block1292 */1293 if (ea_block_cache) {1294 struct mb_cache_entry *oe;1295 1296 oe = mb_cache_entry_delete_or_get(ea_block_cache, hash,1297 bh->b_blocknr);1298 if (oe) {1299 unlock_buffer(bh);1300 mb_cache_entry_wait_unused(oe);1301 mb_cache_entry_put(ea_block_cache, oe);1302 goto retry_ref;1303 }1304 }1305 get_bh(bh);1306 unlock_buffer(bh);1307 1308 if (ext4_has_feature_ea_inode(inode->i_sb))1309 ext4_xattr_inode_dec_ref_all(handle, inode, bh,1310 BFIRST(bh),1311 true /* block_csum */,1312 ea_inode_array,1313 extra_credits,1314 true /* skip_quota */);1315 ext4_free_blocks(handle, inode, bh, 0, 1,1316 EXT4_FREE_BLOCKS_METADATA |1317 EXT4_FREE_BLOCKS_FORGET);1318 } else {1319 ref--;1320 BHDR(bh)->h_refcount = cpu_to_le32(ref);1321 if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {1322 struct mb_cache_entry *ce;1323 1324 if (ea_block_cache) {1325 ce = mb_cache_entry_get(ea_block_cache, hash,1326 bh->b_blocknr);1327 if (ce) {1328 set_bit(MBE_REUSABLE_B, &ce->e_flags);1329 mb_cache_entry_put(ea_block_cache, ce);1330 }1331 }1332 }1333 1334 ext4_xattr_block_csum_set(inode, bh);1335 /*1336 * Beware of this ugliness: Releasing of xattr block references1337 * from different inodes can race and so we have to protect1338 * from a race where someone else frees the block (and releases1339 * its journal_head) before we are done dirtying the buffer. In1340 * nojournal mode this race is harmless and we actually cannot1341 * call ext4_handle_dirty_metadata() with locked buffer as1342 * that function can call sync_dirty_buffer() so for that case1343 * we handle the dirtying after unlocking the buffer.1344 */1345 if (ext4_handle_valid(handle))1346 error = ext4_handle_dirty_metadata(handle, inode, bh);1347 unlock_buffer(bh);1348 if (!ext4_handle_valid(handle))1349 error = ext4_handle_dirty_metadata(handle, inode, bh);1350 if (IS_SYNC(inode))1351 ext4_handle_sync(handle);1352 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));1353 ea_bdebug(bh, "refcount now=%d; releasing",1354 le32_to_cpu(BHDR(bh)->h_refcount));1355 }1356out:1357 ext4_std_error(inode->i_sb, error);1358 return;1359}1360 1361/*1362 * Find the available free space for EAs. This also returns the total number of1363 * bytes used by EA entries.1364 */1365static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,1366 size_t *min_offs, void *base, int *total)1367{1368 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {1369 if (!last->e_value_inum && last->e_value_size) {1370 size_t offs = le16_to_cpu(last->e_value_offs);1371 if (offs < *min_offs)1372 *min_offs = offs;1373 }1374 if (total)1375 *total += EXT4_XATTR_LEN(last->e_name_len);1376 }1377 return (*min_offs - ((void *)last - base) - sizeof(__u32));1378}1379 1380/*1381 * Write the value of the EA in an inode.1382 */1383static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,1384 const void *buf, int bufsize)1385{1386 struct buffer_head *bh = NULL;1387 unsigned long block = 0;1388 int blocksize = ea_inode->i_sb->s_blocksize;1389 int max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits;1390 int csize, wsize = 0;1391 int ret = 0, ret2 = 0;1392 int retries = 0;1393 1394retry:1395 while (ret >= 0 && ret < max_blocks) {1396 struct ext4_map_blocks map;1397 map.m_lblk = block += ret;1398 map.m_len = max_blocks -= ret;1399 1400 ret = ext4_map_blocks(handle, ea_inode, &map,1401 EXT4_GET_BLOCKS_CREATE);1402 if (ret <= 0) {1403 ext4_mark_inode_dirty(handle, ea_inode);1404 if (ret == -ENOSPC &&1405 ext4_should_retry_alloc(ea_inode->i_sb, &retries)) {1406 ret = 0;1407 goto retry;1408 }1409 break;1410 }1411 }1412 1413 if (ret < 0)1414 return ret;1415 1416 block = 0;1417 while (wsize < bufsize) {1418 brelse(bh);1419 csize = (bufsize - wsize) > blocksize ? blocksize :1420 bufsize - wsize;1421 bh = ext4_getblk(handle, ea_inode, block, 0);1422 if (IS_ERR(bh))1423 return PTR_ERR(bh);1424 if (!bh) {1425 WARN_ON_ONCE(1);1426 EXT4_ERROR_INODE(ea_inode,1427 "ext4_getblk() return bh = NULL");1428 return -EFSCORRUPTED;1429 }1430 ret = ext4_journal_get_write_access(handle, ea_inode->i_sb, bh,1431 EXT4_JTR_NONE);1432 if (ret)1433 goto out;1434 1435 memcpy(bh->b_data, buf, csize);1436 /*1437 * Zero out block tail to avoid writing uninitialized memory1438 * to disk.1439 */1440 if (csize < blocksize)1441 memset(bh->b_data + csize, 0, blocksize - csize);1442 set_buffer_uptodate(bh);1443 ext4_handle_dirty_metadata(handle, ea_inode, bh);1444 1445 buf += csize;1446 wsize += csize;1447 block += 1;1448 }1449 1450 inode_lock(ea_inode);1451 i_size_write(ea_inode, wsize);1452 ext4_update_i_disksize(ea_inode, wsize);1453 inode_unlock(ea_inode);1454 1455 ret2 = ext4_mark_inode_dirty(handle, ea_inode);1456 if (unlikely(ret2 && !ret))1457 ret = ret2;1458 1459out:1460 brelse(bh);1461 1462 return ret;1463}1464 1465/*1466 * Create an inode to store the value of a large EA.1467 */1468static struct inode *ext4_xattr_inode_create(handle_t *handle,1469 struct inode *inode, u32 hash)1470{1471 struct inode *ea_inode = NULL;1472 uid_t owner[2] = { i_uid_read(inode), i_gid_read(inode) };1473 int err;1474 1475 if (inode->i_sb->s_root == NULL) {1476 ext4_warning(inode->i_sb,1477 "refuse to create EA inode when umounting");1478 WARN_ON(1);1479 return ERR_PTR(-EINVAL);1480 }1481 1482 /*1483 * Let the next inode be the goal, so we try and allocate the EA inode1484 * in the same group, or nearby one.1485 */1486 ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,1487 S_IFREG | 0600, NULL, inode->i_ino + 1, owner,1488 EXT4_EA_INODE_FL);1489 if (!IS_ERR(ea_inode)) {1490 ea_inode->i_op = &ext4_file_inode_operations;1491 ea_inode->i_fop = &ext4_file_operations;1492 ext4_set_aops(ea_inode);1493 ext4_xattr_inode_set_class(ea_inode);1494 unlock_new_inode(ea_inode);1495 ext4_xattr_inode_set_ref(ea_inode, 1);1496 ext4_xattr_inode_set_hash(ea_inode, hash);1497 err = ext4_mark_inode_dirty(handle, ea_inode);1498 if (!err)1499 err = ext4_inode_attach_jinode(ea_inode);1500 if (err) {1501 if (ext4_xattr_inode_dec_ref(handle, ea_inode))1502 ext4_warning_inode(ea_inode,1503 "cleanup dec ref error %d", err);1504 iput(ea_inode);1505 return ERR_PTR(err);1506 }1507 1508 /*1509 * Xattr inodes are shared therefore quota charging is performed1510 * at a higher level.1511 */1512 dquot_free_inode(ea_inode);1513 dquot_drop(ea_inode);1514 inode_lock(ea_inode);1515 ea_inode->i_flags |= S_NOQUOTA;1516 inode_unlock(ea_inode);1517 }1518 1519 return ea_inode;1520}1521 1522static struct inode *1523ext4_xattr_inode_cache_find(struct inode *inode, const void *value,1524 size_t value_len, u32 hash)1525{1526 struct inode *ea_inode;1527 struct mb_cache_entry *ce;1528 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);1529 void *ea_data;1530 1531 if (!ea_inode_cache)1532 return NULL;1533 1534 ce = mb_cache_entry_find_first(ea_inode_cache, hash);1535 if (!ce)1536 return NULL;1537 1538 WARN_ON_ONCE(ext4_handle_valid(journal_current_handle()) &&1539 !(current->flags & PF_MEMALLOC_NOFS));1540 1541 ea_data = kvmalloc(value_len, GFP_KERNEL);1542 if (!ea_data) {1543 mb_cache_entry_put(ea_inode_cache, ce);1544 return NULL;1545 }1546 1547 while (ce) {1548 ea_inode = ext4_iget(inode->i_sb, ce->e_value,1549 EXT4_IGET_EA_INODE);1550 if (IS_ERR(ea_inode))1551 goto next_entry;1552 ext4_xattr_inode_set_class(ea_inode);1553 if (i_size_read(ea_inode) == value_len &&1554 !ext4_xattr_inode_read(ea_inode, ea_data, value_len) &&1555 !ext4_xattr_inode_verify_hashes(ea_inode, NULL, ea_data,1556 value_len) &&1557 !memcmp(value, ea_data, value_len)) {1558 mb_cache_entry_touch(ea_inode_cache, ce);1559 mb_cache_entry_put(ea_inode_cache, ce);1560 kvfree(ea_data);1561 return ea_inode;1562 }1563 iput(ea_inode);1564 next_entry:1565 ce = mb_cache_entry_find_next(ea_inode_cache, ce);1566 }1567 kvfree(ea_data);1568 return NULL;1569}1570 1571/*1572 * Add value of the EA in an inode.1573 */1574static struct inode *ext4_xattr_inode_lookup_create(handle_t *handle,1575 struct inode *inode, const void *value, size_t value_len)1576{1577 struct inode *ea_inode;1578 u32 hash;1579 int err;1580 1581 /* Account inode & space to quota even if sharing... */1582 err = ext4_xattr_inode_alloc_quota(inode, value_len);1583 if (err)1584 return ERR_PTR(err);1585 1586 hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);1587 ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash);1588 if (ea_inode) {1589 err = ext4_xattr_inode_inc_ref(handle, ea_inode);1590 if (err)1591 goto out_err;1592 return ea_inode;1593 }1594 1595 /* Create an inode for the EA value */1596 ea_inode = ext4_xattr_inode_create(handle, inode, hash);1597 if (IS_ERR(ea_inode)) {1598 ext4_xattr_inode_free_quota(inode, NULL, value_len);1599 return ea_inode;1600 }1601 1602 err = ext4_xattr_inode_write(handle, ea_inode, value, value_len);1603 if (err) {1604 if (ext4_xattr_inode_dec_ref(handle, ea_inode))1605 ext4_warning_inode(ea_inode, "cleanup dec ref error %d", err);1606 goto out_err;1607 }1608 1609 if (EA_INODE_CACHE(inode))1610 mb_cache_entry_create(EA_INODE_CACHE(inode), GFP_NOFS, hash,1611 ea_inode->i_ino, true /* reusable */);1612 return ea_inode;1613out_err:1614 iput(ea_inode);1615 ext4_xattr_inode_free_quota(inode, NULL, value_len);1616 return ERR_PTR(err);1617}1618 1619/*1620 * Reserve min(block_size/8, 1024) bytes for xattr entries/names if ea_inode1621 * feature is enabled.1622 */1623#define EXT4_XATTR_BLOCK_RESERVE(inode) min(i_blocksize(inode)/8, 1024U)1624 1625static int ext4_xattr_set_entry(struct ext4_xattr_info *i,1626 struct ext4_xattr_search *s,1627 handle_t *handle, struct inode *inode,1628 struct inode *new_ea_inode,1629 bool is_block)1630{1631 struct ext4_xattr_entry *last, *next;1632 struct ext4_xattr_entry *here = s->here;1633 size_t min_offs = s->end - s->base, name_len = strlen(i->name);1634 int in_inode = i->in_inode;1635 struct inode *old_ea_inode = NULL;1636 size_t old_size, new_size;1637 int ret;1638 1639 /* Space used by old and new values. */1640 old_size = (!s->not_found && !here->e_value_inum) ?1641 EXT4_XATTR_SIZE(le32_to_cpu(here->e_value_size)) : 0;1642 new_size = (i->value && !in_inode) ? EXT4_XATTR_SIZE(i->value_len) : 0;1643 1644 /*1645 * Optimization for the simple case when old and new values have the1646 * same padded sizes. Not applicable if external inodes are involved.1647 */1648 if (new_size && new_size == old_size) {1649 size_t offs = le16_to_cpu(here->e_value_offs);1650 void *val = s->base + offs;1651 1652 here->e_value_size = cpu_to_le32(i->value_len);1653 if (i->value == EXT4_ZERO_XATTR_VALUE) {1654 memset(val, 0, new_size);1655 } else {1656 memcpy(val, i->value, i->value_len);1657 /* Clear padding bytes. */1658 memset(val + i->value_len, 0, new_size - i->value_len);1659 }1660 goto update_hash;1661 }1662 1663 /* Compute min_offs and last. */1664 last = s->first;1665 for (; !IS_LAST_ENTRY(last); last = next) {1666 next = EXT4_XATTR_NEXT(last);1667 if ((void *)next >= s->end) {1668 EXT4_ERROR_INODE(inode, "corrupted xattr entries");1669 ret = -EFSCORRUPTED;1670 goto out;1671 }1672 if (!last->e_value_inum && last->e_value_size) {1673 size_t offs = le16_to_cpu(last->e_value_offs);1674 if (offs < min_offs)1675 min_offs = offs;1676 }1677 }1678 1679 /* Check whether we have enough space. */1680 if (i->value) {1681 size_t free;1682 1683 free = min_offs - ((void *)last - s->base) - sizeof(__u32);1684 if (!s->not_found)1685 free += EXT4_XATTR_LEN(name_len) + old_size;1686 1687 if (free < EXT4_XATTR_LEN(name_len) + new_size) {1688 ret = -ENOSPC;1689 goto out;1690 }1691 1692 /*1693 * If storing the value in an external inode is an option,1694 * reserve space for xattr entries/names in the external1695 * attribute block so that a long value does not occupy the1696 * whole space and prevent further entries being added.1697 */1698 if (ext4_has_feature_ea_inode(inode->i_sb) &&1699 new_size && is_block &&1700 (min_offs + old_size - new_size) <1701 EXT4_XATTR_BLOCK_RESERVE(inode)) {1702 ret = -ENOSPC;1703 goto out;1704 }1705 }1706 1707 /*1708 * Getting access to old and new ea inodes is subject to failures.1709 * Finish that work before doing any modifications to the xattr data.1710 */1711 if (!s->not_found && here->e_value_inum) {1712 ret = ext4_xattr_inode_iget(inode,1713 le32_to_cpu(here->e_value_inum),1714 le32_to_cpu(here->e_hash),1715 &old_ea_inode);1716 if (ret) {1717 old_ea_inode = NULL;1718 goto out;1719 }1720 1721 /* We are ready to release ref count on the old_ea_inode. */1722 ret = ext4_xattr_inode_dec_ref(handle, old_ea_inode);1723 if (ret)1724 goto out;1725 1726 ext4_xattr_inode_free_quota(inode, old_ea_inode,1727 le32_to_cpu(here->e_value_size));1728 }1729 1730 /* No failures allowed past this point. */1731 1732 if (!s->not_found && here->e_value_size && !here->e_value_inum) {1733 /* Remove the old value. */1734 void *first_val = s->base + min_offs;1735 size_t offs = le16_to_cpu(here->e_value_offs);1736 void *val = s->base + offs;1737 1738 memmove(first_val + old_size, first_val, val - first_val);1739 memset(first_val, 0, old_size);1740 min_offs += old_size;1741 1742 /* Adjust all value offsets. */1743 last = s->first;1744 while (!IS_LAST_ENTRY(last)) {1745 size_t o = le16_to_cpu(last->e_value_offs);1746 1747 if (!last->e_value_inum &&1748 last->e_value_size && o < offs)1749 last->e_value_offs = cpu_to_le16(o + old_size);1750 last = EXT4_XATTR_NEXT(last);1751 }1752 }1753 1754 if (!i->value) {1755 /* Remove old name. */1756 size_t size = EXT4_XATTR_LEN(name_len);1757 1758 last = ENTRY((void *)last - size);1759 memmove(here, (void *)here + size,1760 (void *)last - (void *)here + sizeof(__u32));1761 memset(last, 0, size);1762 1763 /*1764 * Update i_inline_off - moved ibody region might contain1765 * system.data attribute. Handling a failure here won't1766 * cause other complications for setting an xattr.1767 */1768 if (!is_block && ext4_has_inline_data(inode)) {1769 ret = ext4_find_inline_data_nolock(inode);1770 if (ret) {1771 ext4_warning_inode(inode,1772 "unable to update i_inline_off");1773 goto out;1774 }1775 }1776 } else if (s->not_found) {1777 /* Insert new name. */1778 size_t size = EXT4_XATTR_LEN(name_len);1779 size_t rest = (void *)last - (void *)here + sizeof(__u32);1780 1781 memmove((void *)here + size, here, rest);1782 memset(here, 0, size);1783 here->e_name_index = i->name_index;1784 here->e_name_len = name_len;1785 memcpy(here->e_name, i->name, name_len);1786 } else {1787 /* This is an update, reset value info. */1788 here->e_value_inum = 0;1789 here->e_value_offs = 0;1790 here->e_value_size = 0;1791 }1792 1793 if (i->value) {1794 /* Insert new value. */1795 if (in_inode) {1796 here->e_value_inum = cpu_to_le32(new_ea_inode->i_ino);1797 } else if (i->value_len) {1798 void *val = s->base + min_offs - new_size;1799 1800 here->e_value_offs = cpu_to_le16(min_offs - new_size);1801 if (i->value == EXT4_ZERO_XATTR_VALUE) {1802 memset(val, 0, new_size);1803 } else {1804 memcpy(val, i->value, i->value_len);1805 /* Clear padding bytes. */1806 memset(val + i->value_len, 0,1807 new_size - i->value_len);1808 }1809 }1810 here->e_value_size = cpu_to_le32(i->value_len);1811 }1812 1813update_hash:1814 if (i->value) {1815 __le32 hash = 0;1816 1817 /* Entry hash calculation. */1818 if (in_inode) {1819 __le32 crc32c_hash;1820 1821 /*1822 * Feed crc32c hash instead of the raw value for entry1823 * hash calculation. This is to avoid walking1824 * potentially long value buffer again.1825 */1826 crc32c_hash = cpu_to_le32(1827 ext4_xattr_inode_get_hash(new_ea_inode));1828 hash = ext4_xattr_hash_entry(here->e_name,1829 here->e_name_len,1830 &crc32c_hash, 1);1831 } else if (is_block) {1832 __le32 *value = s->base + le16_to_cpu(1833 here->e_value_offs);1834 1835 hash = ext4_xattr_hash_entry(here->e_name,1836 here->e_name_len, value,1837 new_size >> 2);1838 }1839 here->e_hash = hash;1840 }1841 1842 if (is_block)1843 ext4_xattr_rehash((struct ext4_xattr_header *)s->base);1844 1845 ret = 0;1846out:1847 iput(old_ea_inode);1848 return ret;1849}1850 1851struct ext4_xattr_block_find {1852 struct ext4_xattr_search s;1853 struct buffer_head *bh;1854};1855 1856static int1857ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,1858 struct ext4_xattr_block_find *bs)1859{1860 struct super_block *sb = inode->i_sb;1861 int error;1862 1863 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",1864 i->name_index, i->name, i->value, (long)i->value_len);1865 1866 if (EXT4_I(inode)->i_file_acl) {1867 /* The inode already has an extended attribute block. */1868 bs->bh = ext4_sb_bread(sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);1869 if (IS_ERR(bs->bh)) {1870 error = PTR_ERR(bs->bh);1871 bs->bh = NULL;1872 return error;1873 }1874 ea_bdebug(bs->bh, "b_count=%d, refcount=%d",1875 atomic_read(&(bs->bh->b_count)),1876 le32_to_cpu(BHDR(bs->bh)->h_refcount));1877 error = ext4_xattr_check_block(inode, bs->bh);1878 if (error)1879 return error;1880 /* Find the named attribute. */1881 bs->s.base = BHDR(bs->bh);1882 bs->s.first = BFIRST(bs->bh);1883 bs->s.end = bs->bh->b_data + bs->bh->b_size;1884 bs->s.here = bs->s.first;1885 error = xattr_find_entry(inode, &bs->s.here, bs->s.end,1886 i->name_index, i->name, 1);1887 if (error && error != -ENODATA)1888 return error;1889 bs->s.not_found = error;1890 }1891 return 0;1892}1893 1894static int1895ext4_xattr_block_set(handle_t *handle, struct inode *inode,1896 struct ext4_xattr_info *i,1897 struct ext4_xattr_block_find *bs)1898{1899 struct super_block *sb = inode->i_sb;1900 struct buffer_head *new_bh = NULL;1901 struct ext4_xattr_search s_copy = bs->s;1902 struct ext4_xattr_search *s = &s_copy;1903 struct mb_cache_entry *ce = NULL;1904 int error = 0;1905 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);1906 struct inode *ea_inode = NULL, *tmp_inode;1907 size_t old_ea_inode_quota = 0;1908 unsigned int ea_ino;1909 1910#define header(x) ((struct ext4_xattr_header *)(x))1911 1912 /* If we need EA inode, prepare it before locking the buffer */1913 if (i->value && i->in_inode) {1914 WARN_ON_ONCE(!i->value_len);1915 1916 ea_inode = ext4_xattr_inode_lookup_create(handle, inode,1917 i->value, i->value_len);1918 if (IS_ERR(ea_inode)) {1919 error = PTR_ERR(ea_inode);1920 ea_inode = NULL;1921 goto cleanup;1922 }1923 }1924 1925 if (s->base) {1926 int offset = (char *)s->here - bs->bh->b_data;1927 1928 BUFFER_TRACE(bs->bh, "get_write_access");1929 error = ext4_journal_get_write_access(handle, sb, bs->bh,1930 EXT4_JTR_NONE);1931 if (error)1932 goto cleanup;1933 1934 lock_buffer(bs->bh);1935 1936 if (header(s->base)->h_refcount == cpu_to_le32(1)) {1937 __u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);1938 1939 /*1940 * This must happen under buffer lock for1941 * ext4_xattr_block_set() to reliably detect modified1942 * block1943 */1944 if (ea_block_cache) {1945 struct mb_cache_entry *oe;1946 1947 oe = mb_cache_entry_delete_or_get(ea_block_cache,1948 hash, bs->bh->b_blocknr);1949 if (oe) {1950 /*1951 * Xattr block is getting reused. Leave1952 * it alone.1953 */1954 mb_cache_entry_put(ea_block_cache, oe);1955 goto clone_block;1956 }1957 }1958 ea_bdebug(bs->bh, "modifying in-place");1959 error = ext4_xattr_set_entry(i, s, handle, inode,1960 ea_inode, true /* is_block */);1961 ext4_xattr_block_csum_set(inode, bs->bh);1962 unlock_buffer(bs->bh);1963 if (error == -EFSCORRUPTED)1964 goto bad_block;1965 if (!error)1966 error = ext4_handle_dirty_metadata(handle,1967 inode,1968 bs->bh);1969 if (error)1970 goto cleanup;1971 goto inserted;1972 }1973clone_block:1974 unlock_buffer(bs->bh);1975 ea_bdebug(bs->bh, "cloning");1976 s->base = kmemdup(BHDR(bs->bh), bs->bh->b_size, GFP_NOFS);1977 error = -ENOMEM;1978 if (s->base == NULL)1979 goto cleanup;1980 s->first = ENTRY(header(s->base)+1);1981 header(s->base)->h_refcount = cpu_to_le32(1);1982 s->here = ENTRY(s->base + offset);1983 s->end = s->base + bs->bh->b_size;1984 1985 /*1986 * If existing entry points to an xattr inode, we need1987 * to prevent ext4_xattr_set_entry() from decrementing1988 * ref count on it because the reference belongs to the1989 * original block. In this case, make the entry look1990 * like it has an empty value.1991 */1992 if (!s->not_found && s->here->e_value_inum) {1993 ea_ino = le32_to_cpu(s->here->e_value_inum);1994 error = ext4_xattr_inode_iget(inode, ea_ino,1995 le32_to_cpu(s->here->e_hash),1996 &tmp_inode);1997 if (error)1998 goto cleanup;1999 2000 if (!ext4_test_inode_state(tmp_inode,2001 EXT4_STATE_LUSTRE_EA_INODE)) {2002 /*2003 * Defer quota free call for previous2004 * inode until success is guaranteed.2005 */2006 old_ea_inode_quota = le32_to_cpu(2007 s->here->e_value_size);2008 }2009 iput(tmp_inode);2010 2011 s->here->e_value_inum = 0;2012 s->here->e_value_size = 0;2013 }2014 } else {2015 /* Allocate a buffer where we construct the new block. */2016 s->base = kzalloc(sb->s_blocksize, GFP_NOFS);2017 error = -ENOMEM;2018 if (s->base == NULL)2019 goto cleanup;2020 header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);2021 header(s->base)->h_blocks = cpu_to_le32(1);2022 header(s->base)->h_refcount = cpu_to_le32(1);2023 s->first = ENTRY(header(s->base)+1);2024 s->here = ENTRY(header(s->base)+1);2025 s->end = s->base + sb->s_blocksize;2026 }2027 2028 error = ext4_xattr_set_entry(i, s, handle, inode, ea_inode,2029 true /* is_block */);2030 if (error == -EFSCORRUPTED)2031 goto bad_block;2032 if (error)2033 goto cleanup;2034 2035inserted:2036 if (!IS_LAST_ENTRY(s->first)) {2037 new_bh = ext4_xattr_block_cache_find(inode, header(s->base), &ce);2038 if (IS_ERR(new_bh)) {2039 error = PTR_ERR(new_bh);2040 new_bh = NULL;2041 goto cleanup;2042 }2043 2044 if (new_bh) {2045 /* We found an identical block in the cache. */2046 if (new_bh == bs->bh)2047 ea_bdebug(new_bh, "keeping");2048 else {2049 u32 ref;2050 2051#ifdef EXT4_XATTR_DEBUG2052 WARN_ON_ONCE(dquot_initialize_needed(inode));2053#endif2054 /* The old block is released after updating2055 the inode. */2056 error = dquot_alloc_block(inode,2057 EXT4_C2B(EXT4_SB(sb), 1));2058 if (error)2059 goto cleanup;2060 BUFFER_TRACE(new_bh, "get_write_access");2061 error = ext4_journal_get_write_access(2062 handle, sb, new_bh,2063 EXT4_JTR_NONE);2064 if (error)2065 goto cleanup_dquot;2066 lock_buffer(new_bh);2067 /*2068 * We have to be careful about races with2069 * adding references to xattr block. Once we2070 * hold buffer lock xattr block's state is2071 * stable so we can check the additional2072 * reference fits.2073 */2074 ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;2075 if (ref > EXT4_XATTR_REFCOUNT_MAX) {2076 /*2077 * Undo everything and check mbcache2078 * again.2079 */2080 unlock_buffer(new_bh);2081 dquot_free_block(inode,2082 EXT4_C2B(EXT4_SB(sb),2083 1));2084 brelse(new_bh);2085 mb_cache_entry_put(ea_block_cache, ce);2086 ce = NULL;2087 new_bh = NULL;2088 goto inserted;2089 }2090 BHDR(new_bh)->h_refcount = cpu_to_le32(ref);2091 if (ref == EXT4_XATTR_REFCOUNT_MAX)2092 clear_bit(MBE_REUSABLE_B, &ce->e_flags);2093 ea_bdebug(new_bh, "reusing; refcount now=%d",2094 ref);2095 ext4_xattr_block_csum_set(inode, new_bh);2096 unlock_buffer(new_bh);2097 error = ext4_handle_dirty_metadata(handle,2098 inode,2099 new_bh);2100 if (error)2101 goto cleanup_dquot;2102 }2103 mb_cache_entry_touch(ea_block_cache, ce);2104 mb_cache_entry_put(ea_block_cache, ce);2105 ce = NULL;2106 } else if (bs->bh && s->base == bs->bh->b_data) {2107 /* We were modifying this block in-place. */2108 ea_bdebug(bs->bh, "keeping this block");2109 ext4_xattr_block_cache_insert(ea_block_cache, bs->bh);2110 new_bh = bs->bh;2111 get_bh(new_bh);2112 } else {2113 /* We need to allocate a new block */2114 ext4_fsblk_t goal, block;2115 2116#ifdef EXT4_XATTR_DEBUG2117 WARN_ON_ONCE(dquot_initialize_needed(inode));2118#endif2119 goal = ext4_group_first_block_no(sb,2120 EXT4_I(inode)->i_block_group);2121 block = ext4_new_meta_blocks(handle, inode, goal, 0,2122 NULL, &error);2123 if (error)2124 goto cleanup;2125 2126 ea_idebug(inode, "creating block %llu",2127 (unsigned long long)block);2128 2129 new_bh = sb_getblk(sb, block);2130 if (unlikely(!new_bh)) {2131 error = -ENOMEM;2132getblk_failed:2133 ext4_free_blocks(handle, inode, NULL, block, 1,2134 EXT4_FREE_BLOCKS_METADATA);2135 goto cleanup;2136 }2137 error = ext4_xattr_inode_inc_ref_all(handle, inode,2138 ENTRY(header(s->base)+1));2139 if (error)2140 goto getblk_failed;2141 if (ea_inode) {2142 /* Drop the extra ref on ea_inode. */2143 error = ext4_xattr_inode_dec_ref(handle,2144 ea_inode);2145 if (error)2146 ext4_warning_inode(ea_inode,2147 "dec ref error=%d",2148 error);2149 iput(ea_inode);2150 ea_inode = NULL;2151 }2152 2153 lock_buffer(new_bh);2154 error = ext4_journal_get_create_access(handle, sb,2155 new_bh, EXT4_JTR_NONE);2156 if (error) {2157 unlock_buffer(new_bh);2158 error = -EIO;2159 goto getblk_failed;2160 }2161 memcpy(new_bh->b_data, s->base, new_bh->b_size);2162 ext4_xattr_block_csum_set(inode, new_bh);2163 set_buffer_uptodate(new_bh);2164 unlock_buffer(new_bh);2165 ext4_xattr_block_cache_insert(ea_block_cache, new_bh);2166 error = ext4_handle_dirty_metadata(handle, inode,2167 new_bh);2168 if (error)2169 goto cleanup;2170 }2171 }2172 2173 if (old_ea_inode_quota)2174 ext4_xattr_inode_free_quota(inode, NULL, old_ea_inode_quota);2175 2176 /* Update the inode. */2177 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;2178 2179 /* Drop the previous xattr block. */2180 if (bs->bh && bs->bh != new_bh) {2181 struct ext4_xattr_inode_array *ea_inode_array = NULL;2182 2183 ext4_xattr_release_block(handle, inode, bs->bh,2184 &ea_inode_array,2185 0 /* extra_credits */);2186 ext4_xattr_inode_array_free(ea_inode_array);2187 }2188 error = 0;2189 2190cleanup:2191 if (ea_inode) {2192 if (error) {2193 int error2;2194 2195 error2 = ext4_xattr_inode_dec_ref(handle, ea_inode);2196 if (error2)2197 ext4_warning_inode(ea_inode, "dec ref error=%d",2198 error2);2199 ext4_xattr_inode_free_quota(inode, ea_inode,2200 i_size_read(ea_inode));2201 }2202 iput(ea_inode);2203 }2204 if (ce)2205 mb_cache_entry_put(ea_block_cache, ce);2206 brelse(new_bh);2207 if (!(bs->bh && s->base == bs->bh->b_data))2208 kfree(s->base);2209 2210 return error;2211 2212cleanup_dquot:2213 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));2214 goto cleanup;2215 2216bad_block:2217 EXT4_ERROR_INODE(inode, "bad block %llu",2218 EXT4_I(inode)->i_file_acl);2219 goto cleanup;2220 2221#undef header2222}2223 2224int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,2225 struct ext4_xattr_ibody_find *is)2226{2227 struct ext4_xattr_ibody_header *header;2228 struct ext4_inode *raw_inode;2229 int error;2230 2231 if (!EXT4_INODE_HAS_XATTR_SPACE(inode))2232 return 0;2233 2234 raw_inode = ext4_raw_inode(&is->iloc);2235 header = IHDR(inode, raw_inode);2236 is->s.base = is->s.first = IFIRST(header);2237 is->s.here = is->s.first;2238 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;2239 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {2240 error = xattr_check_inode(inode, header, is->s.end);2241 if (error)2242 return error;2243 /* Find the named attribute. */2244 error = xattr_find_entry(inode, &is->s.here, is->s.end,2245 i->name_index, i->name, 0);2246 if (error && error != -ENODATA)2247 return error;2248 is->s.not_found = error;2249 }2250 return 0;2251}2252 2253int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,2254 struct ext4_xattr_info *i,2255 struct ext4_xattr_ibody_find *is)2256{2257 struct ext4_xattr_ibody_header *header;2258 struct ext4_xattr_search *s = &is->s;2259 struct inode *ea_inode = NULL;2260 int error;2261 2262 if (!EXT4_INODE_HAS_XATTR_SPACE(inode))2263 return -ENOSPC;2264 2265 /* If we need EA inode, prepare it before locking the buffer */2266 if (i->value && i->in_inode) {2267 WARN_ON_ONCE(!i->value_len);2268 2269 ea_inode = ext4_xattr_inode_lookup_create(handle, inode,2270 i->value, i->value_len);2271 if (IS_ERR(ea_inode))2272 return PTR_ERR(ea_inode);2273 }2274 error = ext4_xattr_set_entry(i, s, handle, inode, ea_inode,2275 false /* is_block */);2276 if (error) {2277 if (ea_inode) {2278 int error2;2279 2280 error2 = ext4_xattr_inode_dec_ref(handle, ea_inode);2281 if (error2)2282 ext4_warning_inode(ea_inode, "dec ref error=%d",2283 error2);2284 2285 ext4_xattr_inode_free_quota(inode, ea_inode,2286 i_size_read(ea_inode));2287 iput(ea_inode);2288 }2289 return error;2290 }2291 header = IHDR(inode, ext4_raw_inode(&is->iloc));2292 if (!IS_LAST_ENTRY(s->first)) {2293 header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);2294 ext4_set_inode_state(inode, EXT4_STATE_XATTR);2295 } else {2296 header->h_magic = cpu_to_le32(0);2297 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);2298 }2299 iput(ea_inode);2300 return 0;2301}2302 2303static int ext4_xattr_value_same(struct ext4_xattr_search *s,2304 struct ext4_xattr_info *i)2305{2306 void *value;2307 2308 /* When e_value_inum is set the value is stored externally. */2309 if (s->here->e_value_inum)2310 return 0;2311 if (le32_to_cpu(s->here->e_value_size) != i->value_len)2312 return 0;2313 value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);2314 return !memcmp(value, i->value, i->value_len);2315}2316 2317static struct buffer_head *ext4_xattr_get_block(struct inode *inode)2318{2319 struct buffer_head *bh;2320 int error;2321 2322 if (!EXT4_I(inode)->i_file_acl)2323 return NULL;2324 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);2325 if (IS_ERR(bh))2326 return bh;2327 error = ext4_xattr_check_block(inode, bh);2328 if (error) {2329 brelse(bh);2330 return ERR_PTR(error);2331 }2332 return bh;2333}2334 2335/*2336 * ext4_xattr_set_handle()2337 *2338 * Create, replace or remove an extended attribute for this inode. Value2339 * is NULL to remove an existing extended attribute, and non-NULL to2340 * either replace an existing extended attribute, or create a new extended2341 * attribute. The flags XATTR_REPLACE and XATTR_CREATE2342 * specify that an extended attribute must exist and must not exist2343 * previous to the call, respectively.2344 *2345 * Returns 0, or a negative error number on failure.2346 */2347int2348ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,2349 const char *name, const void *value, size_t value_len,2350 int flags)2351{2352 struct ext4_xattr_info i = {2353 .name_index = name_index,2354 .name = name,2355 .value = value,2356 .value_len = value_len,2357 .in_inode = 0,2358 };2359 struct ext4_xattr_ibody_find is = {2360 .s = { .not_found = -ENODATA, },2361 };2362 struct ext4_xattr_block_find bs = {2363 .s = { .not_found = -ENODATA, },2364 };2365 int no_expand;2366 int error;2367 2368 if (!name)2369 return -EINVAL;2370 if (strlen(name) > 255)2371 return -ERANGE;2372 2373 ext4_write_lock_xattr(inode, &no_expand);2374 2375 /* Check journal credits under write lock. */2376 if (ext4_handle_valid(handle)) {2377 struct buffer_head *bh;2378 int credits;2379 2380 bh = ext4_xattr_get_block(inode);2381 if (IS_ERR(bh)) {2382 error = PTR_ERR(bh);2383 goto cleanup;2384 }2385 2386 credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,2387 value_len,2388 flags & XATTR_CREATE);2389 brelse(bh);2390 2391 if (jbd2_handle_buffer_credits(handle) < credits) {2392 error = -ENOSPC;2393 goto cleanup;2394 }2395 WARN_ON_ONCE(!(current->flags & PF_MEMALLOC_NOFS));2396 }2397 2398 error = ext4_reserve_inode_write(handle, inode, &is.iloc);2399 if (error)2400 goto cleanup;2401 2402 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {2403 struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);2404 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);2405 ext4_clear_inode_state(inode, EXT4_STATE_NEW);2406 }2407 2408 error = ext4_xattr_ibody_find(inode, &i, &is);2409 if (error)2410 goto cleanup;2411 if (is.s.not_found)2412 error = ext4_xattr_block_find(inode, &i, &bs);2413 if (error)2414 goto cleanup;2415 if (is.s.not_found && bs.s.not_found) {2416 error = -ENODATA;2417 if (flags & XATTR_REPLACE)2418 goto cleanup;2419 error = 0;2420 if (!value)2421 goto cleanup;2422 } else {2423 error = -EEXIST;2424 if (flags & XATTR_CREATE)2425 goto cleanup;2426 }2427 2428 if (!value) {2429 if (!is.s.not_found)2430 error = ext4_xattr_ibody_set(handle, inode, &i, &is);2431 else if (!bs.s.not_found)2432 error = ext4_xattr_block_set(handle, inode, &i, &bs);2433 } else {2434 error = 0;2435 /* Xattr value did not change? Save us some work and bail out */2436 if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))2437 goto cleanup;2438 if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))2439 goto cleanup;2440 2441 if (ext4_has_feature_ea_inode(inode->i_sb) &&2442 (EXT4_XATTR_SIZE(i.value_len) >2443 EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))2444 i.in_inode = 1;2445retry_inode:2446 error = ext4_xattr_ibody_set(handle, inode, &i, &is);2447 if (!error && !bs.s.not_found) {2448 i.value = NULL;2449 error = ext4_xattr_block_set(handle, inode, &i, &bs);2450 } else if (error == -ENOSPC) {2451 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {2452 brelse(bs.bh);2453 bs.bh = NULL;2454 error = ext4_xattr_block_find(inode, &i, &bs);2455 if (error)2456 goto cleanup;2457 }2458 error = ext4_xattr_block_set(handle, inode, &i, &bs);2459 if (!error && !is.s.not_found) {2460 i.value = NULL;2461 error = ext4_xattr_ibody_set(handle, inode, &i,2462 &is);2463 } else if (error == -ENOSPC) {2464 /*2465 * Xattr does not fit in the block, store at2466 * external inode if possible.2467 */2468 if (ext4_has_feature_ea_inode(inode->i_sb) &&2469 i.value_len && !i.in_inode) {2470 i.in_inode = 1;2471 goto retry_inode;2472 }2473 }2474 }2475 }2476 if (!error) {2477 ext4_xattr_update_super_block(handle, inode->i_sb);2478 inode_set_ctime_current(inode);2479 inode_inc_iversion(inode);2480 if (!value)2481 no_expand = 0;2482 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);2483 /*2484 * The bh is consumed by ext4_mark_iloc_dirty, even with2485 * error != 0.2486 */2487 is.iloc.bh = NULL;2488 if (IS_SYNC(inode))2489 ext4_handle_sync(handle);2490 }2491 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);2492 2493cleanup:2494 brelse(is.iloc.bh);2495 brelse(bs.bh);2496 ext4_write_unlock_xattr(inode, &no_expand);2497 return error;2498}2499 2500int ext4_xattr_set_credits(struct inode *inode, size_t value_len,2501 bool is_create, int *credits)2502{2503 struct buffer_head *bh;2504 int err;2505 2506 *credits = 0;2507 2508 if (!EXT4_SB(inode->i_sb)->s_journal)2509 return 0;2510 2511 down_read(&EXT4_I(inode)->xattr_sem);2512 2513 bh = ext4_xattr_get_block(inode);2514 if (IS_ERR(bh)) {2515 err = PTR_ERR(bh);2516 } else {2517 *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,2518 value_len, is_create);2519 brelse(bh);2520 err = 0;2521 }2522 2523 up_read(&EXT4_I(inode)->xattr_sem);2524 return err;2525}2526 2527/*2528 * ext4_xattr_set()2529 *2530 * Like ext4_xattr_set_handle, but start from an inode. This extended2531 * attribute modification is a filesystem transaction by itself.2532 *2533 * Returns 0, or a negative error number on failure.2534 */2535int2536ext4_xattr_set(struct inode *inode, int name_index, const char *name,2537 const void *value, size_t value_len, int flags)2538{2539 handle_t *handle;2540 struct super_block *sb = inode->i_sb;2541 int error, retries = 0;2542 int credits;2543 2544 error = dquot_initialize(inode);2545 if (error)2546 return error;2547 2548retry:2549 error = ext4_xattr_set_credits(inode, value_len, flags & XATTR_CREATE,2550 &credits);2551 if (error)2552 return error;2553 2554 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);2555 if (IS_ERR(handle)) {2556 error = PTR_ERR(handle);2557 } else {2558 int error2;2559 2560 error = ext4_xattr_set_handle(handle, inode, name_index, name,2561 value, value_len, flags);2562 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR,2563 handle);2564 error2 = ext4_journal_stop(handle);2565 if (error == -ENOSPC &&2566 ext4_should_retry_alloc(sb, &retries))2567 goto retry;2568 if (error == 0)2569 error = error2;2570 }2571 2572 return error;2573}2574 2575/*2576 * Shift the EA entries in the inode to create space for the increased2577 * i_extra_isize.2578 */2579static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,2580 int value_offs_shift, void *to,2581 void *from, size_t n)2582{2583 struct ext4_xattr_entry *last = entry;2584 int new_offs;2585 2586 /* We always shift xattr headers further thus offsets get lower */2587 BUG_ON(value_offs_shift > 0);2588 2589 /* Adjust the value offsets of the entries */2590 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {2591 if (!last->e_value_inum && last->e_value_size) {2592 new_offs = le16_to_cpu(last->e_value_offs) +2593 value_offs_shift;2594 last->e_value_offs = cpu_to_le16(new_offs);2595 }2596 }2597 /* Shift the entries by n bytes */2598 memmove(to, from, n);2599}2600 2601/*2602 * Move xattr pointed to by 'entry' from inode into external xattr block2603 */2604static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,2605 struct ext4_inode *raw_inode,2606 struct ext4_xattr_entry *entry)2607{2608 struct ext4_xattr_ibody_find *is = NULL;2609 struct ext4_xattr_block_find *bs = NULL;2610 char *buffer = NULL, *b_entry_name = NULL;2611 size_t value_size = le32_to_cpu(entry->e_value_size);2612 struct ext4_xattr_info i = {2613 .value = NULL,2614 .value_len = 0,2615 .name_index = entry->e_name_index,2616 .in_inode = !!entry->e_value_inum,2617 };2618 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);2619 int needs_kvfree = 0;2620 int error;2621 2622 is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);2623 bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);2624 b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);2625 if (!is || !bs || !b_entry_name) {2626 error = -ENOMEM;2627 goto out;2628 }2629 2630 is->s.not_found = -ENODATA;2631 bs->s.not_found = -ENODATA;2632 is->iloc.bh = NULL;2633 bs->bh = NULL;2634 2635 /* Save the entry name and the entry value */2636 if (entry->e_value_inum) {2637 buffer = kvmalloc(value_size, GFP_NOFS);2638 if (!buffer) {2639 error = -ENOMEM;2640 goto out;2641 }2642 needs_kvfree = 1;2643 error = ext4_xattr_inode_get(inode, entry, buffer, value_size);2644 if (error)2645 goto out;2646 } else {2647 size_t value_offs = le16_to_cpu(entry->e_value_offs);2648 buffer = (void *)IFIRST(header) + value_offs;2649 }2650 2651 memcpy(b_entry_name, entry->e_name, entry->e_name_len);2652 b_entry_name[entry->e_name_len] = '\0';2653 i.name = b_entry_name;2654 2655 error = ext4_get_inode_loc(inode, &is->iloc);2656 if (error)2657 goto out;2658 2659 error = ext4_xattr_ibody_find(inode, &i, is);2660 if (error)2661 goto out;2662 2663 i.value = buffer;2664 i.value_len = value_size;2665 error = ext4_xattr_block_find(inode, &i, bs);2666 if (error)2667 goto out;2668 2669 /* Move ea entry from the inode into the block */2670 error = ext4_xattr_block_set(handle, inode, &i, bs);2671 if (error)2672 goto out;2673 2674 /* Remove the chosen entry from the inode */2675 i.value = NULL;2676 i.value_len = 0;2677 error = ext4_xattr_ibody_set(handle, inode, &i, is);2678 2679out:2680 kfree(b_entry_name);2681 if (needs_kvfree && buffer)2682 kvfree(buffer);2683 if (is)2684 brelse(is->iloc.bh);2685 if (bs)2686 brelse(bs->bh);2687 kfree(is);2688 kfree(bs);2689 2690 return error;2691}2692 2693static int ext4_xattr_make_inode_space(handle_t *handle, struct inode *inode,2694 struct ext4_inode *raw_inode,2695 int isize_diff, size_t ifree,2696 size_t bfree, int *total_ino)2697{2698 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);2699 struct ext4_xattr_entry *small_entry;2700 struct ext4_xattr_entry *entry;2701 struct ext4_xattr_entry *last;2702 unsigned int entry_size; /* EA entry size */2703 unsigned int total_size; /* EA entry size + value size */2704 unsigned int min_total_size;2705 int error;2706 2707 while (isize_diff > ifree) {2708 entry = NULL;2709 small_entry = NULL;2710 min_total_size = ~0U;2711 last = IFIRST(header);2712 /* Find the entry best suited to be pushed into EA block */2713 for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {2714 /* never move system.data out of the inode */2715 if ((last->e_name_len == 4) &&2716 (last->e_name_index == EXT4_XATTR_INDEX_SYSTEM) &&2717 !memcmp(last->e_name, "data", 4))2718 continue;2719 total_size = EXT4_XATTR_LEN(last->e_name_len);2720 if (!last->e_value_inum)2721 total_size += EXT4_XATTR_SIZE(2722 le32_to_cpu(last->e_value_size));2723 if (total_size <= bfree &&2724 total_size < min_total_size) {2725 if (total_size + ifree < isize_diff) {2726 small_entry = last;2727 } else {2728 entry = last;2729 min_total_size = total_size;2730 }2731 }2732 }2733 2734 if (entry == NULL) {2735 if (small_entry == NULL)2736 return -ENOSPC;2737 entry = small_entry;2738 }2739 2740 entry_size = EXT4_XATTR_LEN(entry->e_name_len);2741 total_size = entry_size;2742 if (!entry->e_value_inum)2743 total_size += EXT4_XATTR_SIZE(2744 le32_to_cpu(entry->e_value_size));2745 error = ext4_xattr_move_to_block(handle, inode, raw_inode,2746 entry);2747 if (error)2748 return error;2749 2750 *total_ino -= entry_size;2751 ifree += total_size;2752 bfree -= total_size;2753 }2754 2755 return 0;2756}2757 2758/*2759 * Expand an inode by new_extra_isize bytes when EAs are present.2760 * Returns 0 on success or negative error number on failure.2761 */2762int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,2763 struct ext4_inode *raw_inode, handle_t *handle)2764{2765 struct ext4_xattr_ibody_header *header;2766 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);2767 static unsigned int mnt_count;2768 size_t min_offs;2769 size_t ifree, bfree;2770 int total_ino;2771 void *base, *end;2772 int error = 0, tried_min_extra_isize = 0;2773 int s_min_extra_isize = le16_to_cpu(sbi->s_es->s_min_extra_isize);2774 int isize_diff; /* How much do we need to grow i_extra_isize */2775 2776retry:2777 isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;2778 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)2779 return 0;2780 2781 header = IHDR(inode, raw_inode);2782 2783 /*2784 * Check if enough free space is available in the inode to shift the2785 * entries ahead by new_extra_isize.2786 */2787 2788 base = IFIRST(header);2789 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;2790 min_offs = end - base;2791 total_ino = sizeof(struct ext4_xattr_ibody_header) + sizeof(u32);2792 2793 error = xattr_check_inode(inode, header, end);2794 if (error)2795 goto cleanup;2796 2797 ifree = ext4_xattr_free_space(base, &min_offs, base, &total_ino);2798 if (ifree >= isize_diff)2799 goto shift;2800 2801 /*2802 * Enough free space isn't available in the inode, check if2803 * EA block can hold new_extra_isize bytes.2804 */2805 if (EXT4_I(inode)->i_file_acl) {2806 struct buffer_head *bh;2807 2808 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);2809 if (IS_ERR(bh)) {2810 error = PTR_ERR(bh);2811 goto cleanup;2812 }2813 error = ext4_xattr_check_block(inode, bh);2814 if (error) {2815 brelse(bh);2816 goto cleanup;2817 }2818 base = BHDR(bh);2819 end = bh->b_data + bh->b_size;2820 min_offs = end - base;2821 bfree = ext4_xattr_free_space(BFIRST(bh), &min_offs, base,2822 NULL);2823 brelse(bh);2824 if (bfree + ifree < isize_diff) {2825 if (!tried_min_extra_isize && s_min_extra_isize) {2826 tried_min_extra_isize++;2827 new_extra_isize = s_min_extra_isize;2828 goto retry;2829 }2830 error = -ENOSPC;2831 goto cleanup;2832 }2833 } else {2834 bfree = inode->i_sb->s_blocksize;2835 }2836 2837 error = ext4_xattr_make_inode_space(handle, inode, raw_inode,2838 isize_diff, ifree, bfree,2839 &total_ino);2840 if (error) {2841 if (error == -ENOSPC && !tried_min_extra_isize &&2842 s_min_extra_isize) {2843 tried_min_extra_isize++;2844 new_extra_isize = s_min_extra_isize;2845 goto retry;2846 }2847 goto cleanup;2848 }2849shift:2850 /* Adjust the offsets and shift the remaining entries ahead */2851 ext4_xattr_shift_entries(IFIRST(header), EXT4_I(inode)->i_extra_isize2852 - new_extra_isize, (void *)raw_inode +2853 EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,2854 (void *)header, total_ino);2855 EXT4_I(inode)->i_extra_isize = new_extra_isize;2856 2857 if (ext4_has_inline_data(inode))2858 error = ext4_find_inline_data_nolock(inode);2859 2860cleanup:2861 if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {2862 ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",2863 inode->i_ino);2864 mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count);2865 }2866 return error;2867}2868 2869#define EIA_INCR 16 /* must be 2^n */2870#define EIA_MASK (EIA_INCR - 1)2871 2872/* Add the large xattr @inode into @ea_inode_array for deferred iput().2873 * If @ea_inode_array is new or full it will be grown and the old2874 * contents copied over.2875 */2876static int2877ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array,2878 struct inode *inode)2879{2880 if (*ea_inode_array == NULL) {2881 /*2882 * Start with 15 inodes, so it fits into a power-of-two size.2883 */2884 (*ea_inode_array) = kmalloc(2885 struct_size(*ea_inode_array, inodes, EIA_MASK),2886 GFP_NOFS);2887 if (*ea_inode_array == NULL)2888 return -ENOMEM;2889 (*ea_inode_array)->count = 0;2890 } else if (((*ea_inode_array)->count & EIA_MASK) == EIA_MASK) {2891 /* expand the array once all 15 + n * 16 slots are full */2892 struct ext4_xattr_inode_array *new_array = NULL;2893 2894 new_array = kmalloc(2895 struct_size(*ea_inode_array, inodes,2896 (*ea_inode_array)->count + EIA_INCR),2897 GFP_NOFS);2898 if (new_array == NULL)2899 return -ENOMEM;2900 memcpy(new_array, *ea_inode_array,2901 struct_size(*ea_inode_array, inodes,2902 (*ea_inode_array)->count));2903 kfree(*ea_inode_array);2904 *ea_inode_array = new_array;2905 }2906 (*ea_inode_array)->count++;2907 (*ea_inode_array)->inodes[(*ea_inode_array)->count - 1] = inode;2908 return 0;2909}2910 2911/*2912 * ext4_xattr_delete_inode()2913 *2914 * Free extended attribute resources associated with this inode. Traverse2915 * all entries and decrement reference on any xattr inodes associated with this2916 * inode. This is called immediately before an inode is freed. We have exclusive2917 * access to the inode. If an orphan inode is deleted it will also release its2918 * references on xattr block and xattr inodes.2919 */2920int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,2921 struct ext4_xattr_inode_array **ea_inode_array,2922 int extra_credits)2923{2924 struct buffer_head *bh = NULL;2925 struct ext4_xattr_ibody_header *header;2926 struct ext4_iloc iloc = { .bh = NULL };2927 struct ext4_xattr_entry *entry;2928 struct inode *ea_inode;2929 int error;2930 2931 error = ext4_journal_ensure_credits(handle, extra_credits,2932 ext4_free_metadata_revoke_credits(inode->i_sb, 1));2933 if (error < 0) {2934 EXT4_ERROR_INODE(inode, "ensure credits (error %d)", error);2935 goto cleanup;2936 }2937 2938 if (ext4_has_feature_ea_inode(inode->i_sb) &&2939 ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {2940 2941 error = ext4_get_inode_loc(inode, &iloc);2942 if (error) {2943 EXT4_ERROR_INODE(inode, "inode loc (error %d)", error);2944 goto cleanup;2945 }2946 2947 error = ext4_journal_get_write_access(handle, inode->i_sb,2948 iloc.bh, EXT4_JTR_NONE);2949 if (error) {2950 EXT4_ERROR_INODE(inode, "write access (error %d)",2951 error);2952 goto cleanup;2953 }2954 2955 header = IHDR(inode, ext4_raw_inode(&iloc));2956 if (header->h_magic == cpu_to_le32(EXT4_XATTR_MAGIC))2957 ext4_xattr_inode_dec_ref_all(handle, inode, iloc.bh,2958 IFIRST(header),2959 false /* block_csum */,2960 ea_inode_array,2961 extra_credits,2962 false /* skip_quota */);2963 }2964 2965 if (EXT4_I(inode)->i_file_acl) {2966 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);2967 if (IS_ERR(bh)) {2968 error = PTR_ERR(bh);2969 if (error == -EIO) {2970 EXT4_ERROR_INODE_ERR(inode, EIO,2971 "block %llu read error",2972 EXT4_I(inode)->i_file_acl);2973 }2974 bh = NULL;2975 goto cleanup;2976 }2977 error = ext4_xattr_check_block(inode, bh);2978 if (error)2979 goto cleanup;2980 2981 if (ext4_has_feature_ea_inode(inode->i_sb)) {2982 for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);2983 entry = EXT4_XATTR_NEXT(entry)) {2984 if (!entry->e_value_inum)2985 continue;2986 error = ext4_xattr_inode_iget(inode,2987 le32_to_cpu(entry->e_value_inum),2988 le32_to_cpu(entry->e_hash),2989 &ea_inode);2990 if (error)2991 continue;2992 ext4_xattr_inode_free_quota(inode, ea_inode,2993 le32_to_cpu(entry->e_value_size));2994 iput(ea_inode);2995 }2996 2997 }2998 2999 ext4_xattr_release_block(handle, inode, bh, ea_inode_array,3000 extra_credits);3001 /*3002 * Update i_file_acl value in the same transaction that releases3003 * block.3004 */3005 EXT4_I(inode)->i_file_acl = 0;3006 error = ext4_mark_inode_dirty(handle, inode);3007 if (error) {3008 EXT4_ERROR_INODE(inode, "mark inode dirty (error %d)",3009 error);3010 goto cleanup;3011 }3012 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);3013 }3014 error = 0;3015cleanup:3016 brelse(iloc.bh);3017 brelse(bh);3018 return error;3019}3020 3021void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *ea_inode_array)3022{3023 int idx;3024 3025 if (ea_inode_array == NULL)3026 return;3027 3028 for (idx = 0; idx < ea_inode_array->count; ++idx)3029 iput(ea_inode_array->inodes[idx]);3030 kfree(ea_inode_array);3031}3032 3033/*3034 * ext4_xattr_block_cache_insert()3035 *3036 * Create a new entry in the extended attribute block cache, and insert3037 * it unless such an entry is already in the cache.3038 */3039static void3040ext4_xattr_block_cache_insert(struct mb_cache *ea_block_cache,3041 struct buffer_head *bh)3042{3043 struct ext4_xattr_header *header = BHDR(bh);3044 __u32 hash = le32_to_cpu(header->h_hash);3045 int reusable = le32_to_cpu(header->h_refcount) <3046 EXT4_XATTR_REFCOUNT_MAX;3047 int error;3048 3049 if (!ea_block_cache)3050 return;3051 error = mb_cache_entry_create(ea_block_cache, GFP_NOFS, hash,3052 bh->b_blocknr, reusable);3053 if (error) {3054 if (error == -EBUSY)3055 ea_bdebug(bh, "already in cache");3056 } else3057 ea_bdebug(bh, "inserting [%x]", (int)hash);3058}3059 3060/*3061 * ext4_xattr_cmp()3062 *3063 * Compare two extended attribute blocks for equality.3064 *3065 * Returns 0 if the blocks are equal, 1 if they differ.3066 */3067static int3068ext4_xattr_cmp(struct ext4_xattr_header *header1,3069 struct ext4_xattr_header *header2)3070{3071 struct ext4_xattr_entry *entry1, *entry2;3072 3073 entry1 = ENTRY(header1+1);3074 entry2 = ENTRY(header2+1);3075 while (!IS_LAST_ENTRY(entry1)) {3076 if (IS_LAST_ENTRY(entry2))3077 return 1;3078 if (entry1->e_hash != entry2->e_hash ||3079 entry1->e_name_index != entry2->e_name_index ||3080 entry1->e_name_len != entry2->e_name_len ||3081 entry1->e_value_size != entry2->e_value_size ||3082 entry1->e_value_inum != entry2->e_value_inum ||3083 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))3084 return 1;3085 if (!entry1->e_value_inum &&3086 memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),3087 (char *)header2 + le16_to_cpu(entry2->e_value_offs),3088 le32_to_cpu(entry1->e_value_size)))3089 return 1;3090 3091 entry1 = EXT4_XATTR_NEXT(entry1);3092 entry2 = EXT4_XATTR_NEXT(entry2);3093 }3094 if (!IS_LAST_ENTRY(entry2))3095 return 1;3096 return 0;3097}3098 3099/*3100 * ext4_xattr_block_cache_find()3101 *3102 * Find an identical extended attribute block.3103 *3104 * Returns a pointer to the block found, or NULL if such a block was not3105 * found, or an error pointer if an error occurred while reading ea block.3106 */3107static struct buffer_head *3108ext4_xattr_block_cache_find(struct inode *inode,3109 struct ext4_xattr_header *header,3110 struct mb_cache_entry **pce)3111{3112 __u32 hash = le32_to_cpu(header->h_hash);3113 struct mb_cache_entry *ce;3114 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);3115 3116 if (!ea_block_cache)3117 return NULL;3118 if (!header->h_hash)3119 return NULL; /* never share */3120 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);3121 ce = mb_cache_entry_find_first(ea_block_cache, hash);3122 while (ce) {3123 struct buffer_head *bh;3124 3125 bh = ext4_sb_bread(inode->i_sb, ce->e_value, REQ_PRIO);3126 if (IS_ERR(bh)) {3127 if (PTR_ERR(bh) != -ENOMEM)3128 EXT4_ERROR_INODE(inode, "block %lu read error",3129 (unsigned long)ce->e_value);3130 mb_cache_entry_put(ea_block_cache, ce);3131 return bh;3132 } else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {3133 *pce = ce;3134 return bh;3135 }3136 brelse(bh);3137 ce = mb_cache_entry_find_next(ea_block_cache, ce);3138 }3139 return NULL;3140}3141 3142#define NAME_HASH_SHIFT 53143#define VALUE_HASH_SHIFT 163144 3145/*3146 * ext4_xattr_hash_entry()3147 *3148 * Compute the hash of an extended attribute.3149 */3150static __le32 ext4_xattr_hash_entry(char *name, size_t name_len, __le32 *value,3151 size_t value_count)3152{3153 __u32 hash = 0;3154 3155 while (name_len--) {3156 hash = (hash << NAME_HASH_SHIFT) ^3157 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^3158 (unsigned char)*name++;3159 }3160 while (value_count--) {3161 hash = (hash << VALUE_HASH_SHIFT) ^3162 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^3163 le32_to_cpu(*value++);3164 }3165 return cpu_to_le32(hash);3166}3167 3168/*3169 * ext4_xattr_hash_entry_signed()3170 *3171 * Compute the hash of an extended attribute incorrectly.3172 */3173static __le32 ext4_xattr_hash_entry_signed(char *name, size_t name_len, __le32 *value, size_t value_count)3174{3175 __u32 hash = 0;3176 3177 while (name_len--) {3178 hash = (hash << NAME_HASH_SHIFT) ^3179 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^3180 (signed char)*name++;3181 }3182 while (value_count--) {3183 hash = (hash << VALUE_HASH_SHIFT) ^3184 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^3185 le32_to_cpu(*value++);3186 }3187 return cpu_to_le32(hash);3188}3189 3190#undef NAME_HASH_SHIFT3191#undef VALUE_HASH_SHIFT3192 3193#define BLOCK_HASH_SHIFT 163194 3195/*3196 * ext4_xattr_rehash()3197 *3198 * Re-compute the extended attribute hash value after an entry has changed.3199 */3200static void ext4_xattr_rehash(struct ext4_xattr_header *header)3201{3202 struct ext4_xattr_entry *here;3203 __u32 hash = 0;3204 3205 here = ENTRY(header+1);3206 while (!IS_LAST_ENTRY(here)) {3207 if (!here->e_hash) {3208 /* Block is not shared if an entry's hash value == 0 */3209 hash = 0;3210 break;3211 }3212 hash = (hash << BLOCK_HASH_SHIFT) ^3213 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^3214 le32_to_cpu(here->e_hash);3215 here = EXT4_XATTR_NEXT(here);3216 }3217 header->h_hash = cpu_to_le32(hash);3218}3219 3220#undef BLOCK_HASH_SHIFT3221 3222#define HASH_BUCKET_BITS 103223 3224struct mb_cache *3225ext4_xattr_create_cache(void)3226{3227 return mb_cache_create(HASH_BUCKET_BITS);3228}3229 3230void ext4_xattr_destroy_cache(struct mb_cache *cache)3231{3232 if (cache)3233 mb_cache_destroy(cache);3234}3235 3236