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