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