1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/ext2/xattr.c 4 * 5 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de> 6 * 7 * Fix by Harrison Xing <harrison@mountainviewdata.com>. 8 * Extended attributes for symlinks and special files added per 9 * suggestion of Luka Renko <luka.renko@hermes.si>. 10 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>, 11 * Red Hat Inc. 12 * 13 */ 14 15 /* 16 * Extended attributes are stored on disk blocks allocated outside of 17 * any inode. The i_file_acl field is then made to point to this allocated 18 * block. If all extended attributes of an inode are identical, these 19 * inodes may share the same extended attribute block. Such situations 20 * are automatically detected by keeping a cache of recent attribute block 21 * numbers and hashes over the block's contents in memory. 22 * 23 * 24 * Extended attribute block layout: 25 * 26 * +------------------+ 27 * | header | 28 * | entry 1 | | 29 * | entry 2 | | growing downwards 30 * | entry 3 | v 31 * | four null bytes | 32 * | . . . | 33 * | value 1 | ^ 34 * | value 3 | | growing upwards 35 * | value 2 | | 36 * +------------------+ 37 * 38 * The block header is followed by multiple entry descriptors. These entry 39 * descriptors are variable in size, and aligned to EXT2_XATTR_PAD 40 * byte boundaries. The entry descriptors are sorted by attribute name, 41 * so that two extended attribute blocks can be compared efficiently. 42 * 43 * Attribute values are aligned to the end of the block, stored in 44 * no specific order. They are also padded to EXT2_XATTR_PAD byte 45 * boundaries. No additional gaps are left between them. 46 * 47 * Locking strategy 48 * ---------------- 49 * EXT2_I(inode)->i_file_acl is protected by EXT2_I(inode)->xattr_sem. 50 * EA blocks are only changed if they are exclusive to an inode, so 51 * holding xattr_sem also means that nothing but the EA block's reference 52 * count will change. Multiple writers to an EA block are synchronized 53 * by the bh lock. No more than a single bh lock is held at any time 54 * to avoid deadlocks. 55 */ 56 57 #include <linux/buffer_head.h> 58 #include <linux/init.h> 59 #include <linux/slab.h> 60 #include <linux/mbcache.h> 61 #include <linux/quotaops.h> 62 #include <linux/rwsem.h> 63 #include <linux/security.h> 64 #include "ext2.h" 65 #include "xattr.h" 66 #include "acl.h" 67 68 #define HDR(bh) ((struct ext2_xattr_header *)((bh)->b_data)) 69 #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr)) 70 #define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1) 71 #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0) 72 73 #ifdef EXT2_XATTR_DEBUG 74 # define ea_idebug(inode, f...) do { \ 75 printk(KERN_DEBUG "inode %s:%ld: ", \ 76 inode->i_sb->s_id, inode->i_ino); \ 77 printk(f); \ 78 printk("\n"); \ 79 } while (0) 80 # define ea_bdebug(bh, f...) do { \ 81 printk(KERN_DEBUG "block %pg:%lu: ", \ 82 bh->b_bdev, (unsigned long) bh->b_blocknr); \ 83 printk(f); \ 84 printk("\n"); \ 85 } while (0) 86 #else 87 # define ea_idebug(f...) 88 # define ea_bdebug(f...) 89 #endif 90 91 static int ext2_xattr_set2(struct inode *, struct buffer_head *, 92 struct ext2_xattr_header *); 93 94 static int ext2_xattr_cache_insert(struct mb_cache *, struct buffer_head *); 95 static struct buffer_head *ext2_xattr_cache_find(struct inode *, 96 struct ext2_xattr_header *); 97 static void ext2_xattr_rehash(struct ext2_xattr_header *, 98 struct ext2_xattr_entry *); 99 100 static const struct xattr_handler *ext2_xattr_handler_map[] = { 101 [EXT2_XATTR_INDEX_USER] = &ext2_xattr_user_handler, 102 #ifdef CONFIG_EXT2_FS_POSIX_ACL 103 [EXT2_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler, 104 [EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler, 105 #endif 106 [EXT2_XATTR_INDEX_TRUSTED] = &ext2_xattr_trusted_handler, 107 #ifdef CONFIG_EXT2_FS_SECURITY 108 [EXT2_XATTR_INDEX_SECURITY] = &ext2_xattr_security_handler, 109 #endif 110 }; 111 112 const struct xattr_handler *ext2_xattr_handlers[] = { 113 &ext2_xattr_user_handler, 114 &ext2_xattr_trusted_handler, 115 #ifdef CONFIG_EXT2_FS_POSIX_ACL 116 &posix_acl_access_xattr_handler, 117 &posix_acl_default_xattr_handler, 118 #endif 119 #ifdef CONFIG_EXT2_FS_SECURITY 120 &ext2_xattr_security_handler, 121 #endif 122 NULL 123 }; 124 125 #define EA_BLOCK_CACHE(inode) (EXT2_SB(inode->i_sb)->s_ea_block_cache) 126 127 static inline const struct xattr_handler * 128 ext2_xattr_handler(int name_index) 129 { 130 const struct xattr_handler *handler = NULL; 131 132 if (name_index > 0 && name_index < ARRAY_SIZE(ext2_xattr_handler_map)) 133 handler = ext2_xattr_handler_map[name_index]; 134 return handler; 135 } 136 137 static bool 138 ext2_xattr_header_valid(struct ext2_xattr_header *header) 139 { 140 if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) || 141 header->h_blocks != cpu_to_le32(1)) 142 return false; 143 144 return true; 145 } 146 147 static bool 148 ext2_xattr_entry_valid(struct ext2_xattr_entry *entry, 149 char *end, size_t end_offs) 150 { 151 struct ext2_xattr_entry *next; 152 size_t size; 153 154 next = EXT2_XATTR_NEXT(entry); 155 if ((char *)next >= end) 156 return false; 157 158 if (entry->e_value_block != 0) 159 return false; 160 161 size = le32_to_cpu(entry->e_value_size); 162 if (size > end_offs || 163 le16_to_cpu(entry->e_value_offs) + size > end_offs) 164 return false; 165 166 return true; 167 } 168 169 static int 170 ext2_xattr_cmp_entry(int name_index, size_t name_len, const char *name, 171 struct ext2_xattr_entry *entry) 172 { 173 int cmp; 174 175 cmp = name_index - entry->e_name_index; 176 if (!cmp) 177 cmp = name_len - entry->e_name_len; 178 if (!cmp) 179 cmp = memcmp(name, entry->e_name, name_len); 180 181 return cmp; 182 } 183 184 /* 185 * ext2_xattr_get() 186 * 187 * Copy an extended attribute into the buffer 188 * provided, or compute the buffer size required. 189 * Buffer is NULL to compute the size of the buffer required. 190 * 191 * Returns a negative error number on failure, or the number of bytes 192 * used / required on success. 193 */ 194 int 195 ext2_xattr_get(struct inode *inode, int name_index, const char *name, 196 void *buffer, size_t buffer_size) 197 { 198 struct buffer_head *bh = NULL; 199 struct ext2_xattr_entry *entry; 200 size_t name_len, size; 201 char *end; 202 int error; 203 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode); 204 205 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld", 206 name_index, name, buffer, (long)buffer_size); 207 208 if (name == NULL) 209 return -EINVAL; 210 name_len = strlen(name); 211 if (name_len > 255) 212 return -ERANGE; 213 214 down_read(&EXT2_I(inode)->xattr_sem); 215 error = -ENODATA; 216 if (!EXT2_I(inode)->i_file_acl) 217 goto cleanup; 218 ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl); 219 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); 220 error = -EIO; 221 if (!bh) 222 goto cleanup; 223 ea_bdebug(bh, "b_count=%d, refcount=%d", 224 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount)); 225 end = bh->b_data + bh->b_size; 226 if (!ext2_xattr_header_valid(HDR(bh))) { 227 bad_block: 228 ext2_error(inode->i_sb, "ext2_xattr_get", 229 "inode %ld: bad block %d", inode->i_ino, 230 EXT2_I(inode)->i_file_acl); 231 error = -EIO; 232 goto cleanup; 233 } 234 235 /* find named attribute */ 236 entry = FIRST_ENTRY(bh); 237 while (!IS_LAST_ENTRY(entry)) { 238 if (!ext2_xattr_entry_valid(entry, end, 239 inode->i_sb->s_blocksize)) 240 goto bad_block; 241 if (name_index == entry->e_name_index && 242 name_len == entry->e_name_len && 243 memcmp(name, entry->e_name, name_len) == 0) 244 goto found; 245 entry = EXT2_XATTR_NEXT(entry); 246 } 247 if (ext2_xattr_cache_insert(ea_block_cache, bh)) 248 ea_idebug(inode, "cache insert failed"); 249 error = -ENODATA; 250 goto cleanup; 251 found: 252 size = le32_to_cpu(entry->e_value_size); 253 if (ext2_xattr_cache_insert(ea_block_cache, bh)) 254 ea_idebug(inode, "cache insert failed"); 255 if (buffer) { 256 error = -ERANGE; 257 if (size > buffer_size) 258 goto cleanup; 259 /* return value of attribute */ 260 memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs), 261 size); 262 } 263 error = size; 264 265 cleanup: 266 brelse(bh); 267 up_read(&EXT2_I(inode)->xattr_sem); 268 269 return error; 270 } 271 272 /* 273 * ext2_xattr_list() 274 * 275 * Copy a list of attribute names into the buffer 276 * provided, or compute the buffer size required. 277 * Buffer is NULL to compute the size of the buffer required. 278 * 279 * Returns a negative error number on failure, or the number of bytes 280 * used / required on success. 281 */ 282 static int 283 ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size) 284 { 285 struct inode *inode = d_inode(dentry); 286 struct buffer_head *bh = NULL; 287 struct ext2_xattr_entry *entry; 288 char *end; 289 size_t rest = buffer_size; 290 int error; 291 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode); 292 293 ea_idebug(inode, "buffer=%p, buffer_size=%ld", 294 buffer, (long)buffer_size); 295 296 down_read(&EXT2_I(inode)->xattr_sem); 297 error = 0; 298 if (!EXT2_I(inode)->i_file_acl) 299 goto cleanup; 300 ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl); 301 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); 302 error = -EIO; 303 if (!bh) 304 goto cleanup; 305 ea_bdebug(bh, "b_count=%d, refcount=%d", 306 atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount)); 307 end = bh->b_data + bh->b_size; 308 if (!ext2_xattr_header_valid(HDR(bh))) { 309 bad_block: 310 ext2_error(inode->i_sb, "ext2_xattr_list", 311 "inode %ld: bad block %d", inode->i_ino, 312 EXT2_I(inode)->i_file_acl); 313 error = -EIO; 314 goto cleanup; 315 } 316 317 /* check the on-disk data structure */ 318 entry = FIRST_ENTRY(bh); 319 while (!IS_LAST_ENTRY(entry)) { 320 if (!ext2_xattr_entry_valid(entry, end, 321 inode->i_sb->s_blocksize)) 322 goto bad_block; 323 entry = EXT2_XATTR_NEXT(entry); 324 } 325 if (ext2_xattr_cache_insert(ea_block_cache, bh)) 326 ea_idebug(inode, "cache insert failed"); 327 328 /* list the attribute names */ 329 for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry); 330 entry = EXT2_XATTR_NEXT(entry)) { 331 const struct xattr_handler *handler = 332 ext2_xattr_handler(entry->e_name_index); 333 334 if (handler && (!handler->list || handler->list(dentry))) { 335 const char *prefix = handler->prefix ?: handler->name; 336 size_t prefix_len = strlen(prefix); 337 size_t size = prefix_len + entry->e_name_len + 1; 338 339 if (buffer) { 340 if (size > rest) { 341 error = -ERANGE; 342 goto cleanup; 343 } 344 memcpy(buffer, prefix, prefix_len); 345 buffer += prefix_len; 346 memcpy(buffer, entry->e_name, entry->e_name_len); 347 buffer += entry->e_name_len; 348 *buffer++ = 0; 349 } 350 rest -= size; 351 } 352 } 353 error = buffer_size - rest; /* total size */ 354 355 cleanup: 356 brelse(bh); 357 up_read(&EXT2_I(inode)->xattr_sem); 358 359 return error; 360 } 361 362 /* 363 * Inode operation listxattr() 364 * 365 * d_inode(dentry)->i_mutex: don't care 366 */ 367 ssize_t 368 ext2_listxattr(struct dentry *dentry, char *buffer, size_t size) 369 { 370 return ext2_xattr_list(dentry, buffer, size); 371 } 372 373 /* 374 * If the EXT2_FEATURE_COMPAT_EXT_ATTR feature of this file system is 375 * not set, set it. 376 */ 377 static void ext2_xattr_update_super_block(struct super_block *sb) 378 { 379 if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR)) 380 return; 381 382 spin_lock(&EXT2_SB(sb)->s_lock); 383 ext2_update_dynamic_rev(sb); 384 EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR); 385 spin_unlock(&EXT2_SB(sb)->s_lock); 386 mark_buffer_dirty(EXT2_SB(sb)->s_sbh); 387 } 388 389 /* 390 * ext2_xattr_set() 391 * 392 * Create, replace or remove an extended attribute for this inode. Value 393 * is NULL to remove an existing extended attribute, and non-NULL to 394 * either replace an existing extended attribute, or create a new extended 395 * attribute. The flags XATTR_REPLACE and XATTR_CREATE 396 * specify that an extended attribute must exist and must not exist 397 * previous to the call, respectively. 398 * 399 * Returns 0, or a negative error number on failure. 400 */ 401 int 402 ext2_xattr_set(struct inode *inode, int name_index, const char *name, 403 const void *value, size_t value_len, int flags) 404 { 405 struct super_block *sb = inode->i_sb; 406 struct buffer_head *bh = NULL; 407 struct ext2_xattr_header *header = NULL; 408 struct ext2_xattr_entry *here = NULL, *last = NULL; 409 size_t name_len, free, min_offs = sb->s_blocksize; 410 int not_found = 1, error; 411 char *end; 412 413 /* 414 * header -- Points either into bh, or to a temporarily 415 * allocated buffer. 416 * here -- The named entry found, or the place for inserting, within 417 * the block pointed to by header. 418 * last -- Points right after the last named entry within the block 419 * pointed to by header. 420 * min_offs -- The offset of the first value (values are aligned 421 * towards the end of the block). 422 * end -- Points right after the block pointed to by header. 423 */ 424 425 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld", 426 name_index, name, value, (long)value_len); 427 428 if (value == NULL) 429 value_len = 0; 430 if (name == NULL) 431 return -EINVAL; 432 name_len = strlen(name); 433 if (name_len > 255 || value_len > sb->s_blocksize) 434 return -ERANGE; 435 down_write(&EXT2_I(inode)->xattr_sem); 436 if (EXT2_I(inode)->i_file_acl) { 437 /* The inode already has an extended attribute block. */ 438 bh = sb_bread(sb, EXT2_I(inode)->i_file_acl); 439 error = -EIO; 440 if (!bh) 441 goto cleanup; 442 ea_bdebug(bh, "b_count=%d, refcount=%d", 443 atomic_read(&(bh->b_count)), 444 le32_to_cpu(HDR(bh)->h_refcount)); 445 header = HDR(bh); 446 end = bh->b_data + bh->b_size; 447 if (!ext2_xattr_header_valid(header)) { 448 bad_block: 449 ext2_error(sb, "ext2_xattr_set", 450 "inode %ld: bad block %d", inode->i_ino, 451 EXT2_I(inode)->i_file_acl); 452 error = -EIO; 453 goto cleanup; 454 } 455 /* 456 * Find the named attribute. If not found, 'here' will point 457 * to entry where the new attribute should be inserted to 458 * maintain sorting. 459 */ 460 last = FIRST_ENTRY(bh); 461 while (!IS_LAST_ENTRY(last)) { 462 if (!ext2_xattr_entry_valid(last, end, sb->s_blocksize)) 463 goto bad_block; 464 if (last->e_value_size) { 465 size_t offs = le16_to_cpu(last->e_value_offs); 466 if (offs < min_offs) 467 min_offs = offs; 468 } 469 if (not_found > 0) { 470 not_found = ext2_xattr_cmp_entry(name_index, 471 name_len, 472 name, last); 473 if (not_found <= 0) 474 here = last; 475 } 476 last = EXT2_XATTR_NEXT(last); 477 } 478 if (not_found > 0) 479 here = last; 480 481 /* Check whether we have enough space left. */ 482 free = min_offs - ((char*)last - (char*)header) - sizeof(__u32); 483 } else { 484 /* We will use a new extended attribute block. */ 485 free = sb->s_blocksize - 486 sizeof(struct ext2_xattr_header) - sizeof(__u32); 487 } 488 489 if (not_found) { 490 /* Request to remove a nonexistent attribute? */ 491 error = -ENODATA; 492 if (flags & XATTR_REPLACE) 493 goto cleanup; 494 error = 0; 495 if (value == NULL) 496 goto cleanup; 497 } else { 498 /* Request to create an existing attribute? */ 499 error = -EEXIST; 500 if (flags & XATTR_CREATE) 501 goto cleanup; 502 free += EXT2_XATTR_SIZE(le32_to_cpu(here->e_value_size)); 503 free += EXT2_XATTR_LEN(name_len); 504 } 505 error = -ENOSPC; 506 if (free < EXT2_XATTR_LEN(name_len) + EXT2_XATTR_SIZE(value_len)) 507 goto cleanup; 508 509 /* Here we know that we can set the new attribute. */ 510 511 if (header) { 512 /* assert(header == HDR(bh)); */ 513 lock_buffer(bh); 514 if (header->h_refcount == cpu_to_le32(1)) { 515 __u32 hash = le32_to_cpu(header->h_hash); 516 517 ea_bdebug(bh, "modifying in-place"); 518 /* 519 * This must happen under buffer lock for 520 * ext2_xattr_set2() to reliably detect modified block 521 */ 522 mb_cache_entry_delete(EA_BLOCK_CACHE(inode), hash, 523 bh->b_blocknr); 524 525 /* keep the buffer locked while modifying it. */ 526 } else { 527 int offset; 528 529 unlock_buffer(bh); 530 ea_bdebug(bh, "cloning"); 531 header = kmalloc(bh->b_size, GFP_KERNEL); 532 error = -ENOMEM; 533 if (header == NULL) 534 goto cleanup; 535 memcpy(header, HDR(bh), bh->b_size); 536 header->h_refcount = cpu_to_le32(1); 537 538 offset = (char *)here - bh->b_data; 539 here = ENTRY((char *)header + offset); 540 offset = (char *)last - bh->b_data; 541 last = ENTRY((char *)header + offset); 542 } 543 } else { 544 /* Allocate a buffer where we construct the new block. */ 545 header = kzalloc(sb->s_blocksize, GFP_KERNEL); 546 error = -ENOMEM; 547 if (header == NULL) 548 goto cleanup; 549 end = (char *)header + sb->s_blocksize; 550 header->h_magic = cpu_to_le32(EXT2_XATTR_MAGIC); 551 header->h_blocks = header->h_refcount = cpu_to_le32(1); 552 last = here = ENTRY(header+1); 553 } 554 555 /* Iff we are modifying the block in-place, bh is locked here. */ 556 557 if (not_found) { 558 /* Insert the new name. */ 559 size_t size = EXT2_XATTR_LEN(name_len); 560 size_t rest = (char *)last - (char *)here; 561 memmove((char *)here + size, here, rest); 562 memset(here, 0, size); 563 here->e_name_index = name_index; 564 here->e_name_len = name_len; 565 memcpy(here->e_name, name, name_len); 566 } else { 567 if (here->e_value_size) { 568 char *first_val = (char *)header + min_offs; 569 size_t offs = le16_to_cpu(here->e_value_offs); 570 char *val = (char *)header + offs; 571 size_t size = EXT2_XATTR_SIZE( 572 le32_to_cpu(here->e_value_size)); 573 574 if (size == EXT2_XATTR_SIZE(value_len)) { 575 /* The old and the new value have the same 576 size. Just replace. */ 577 here->e_value_size = cpu_to_le32(value_len); 578 memset(val + size - EXT2_XATTR_PAD, 0, 579 EXT2_XATTR_PAD); /* Clear pad bytes. */ 580 memcpy(val, value, value_len); 581 goto skip_replace; 582 } 583 584 /* Remove the old value. */ 585 memmove(first_val + size, first_val, val - first_val); 586 memset(first_val, 0, size); 587 here->e_value_offs = 0; 588 min_offs += size; 589 590 /* Adjust all value offsets. */ 591 last = ENTRY(header+1); 592 while (!IS_LAST_ENTRY(last)) { 593 size_t o = le16_to_cpu(last->e_value_offs); 594 if (o < offs) 595 last->e_value_offs = 596 cpu_to_le16(o + size); 597 last = EXT2_XATTR_NEXT(last); 598 } 599 } 600 if (value == NULL) { 601 /* Remove the old name. */ 602 size_t size = EXT2_XATTR_LEN(name_len); 603 last = ENTRY((char *)last - size); 604 memmove(here, (char*)here + size, 605 (char*)last - (char*)here); 606 memset(last, 0, size); 607 } 608 } 609 610 if (value != NULL) { 611 /* Insert the new value. */ 612 here->e_value_size = cpu_to_le32(value_len); 613 if (value_len) { 614 size_t size = EXT2_XATTR_SIZE(value_len); 615 char *val = (char *)header + min_offs - size; 616 here->e_value_offs = 617 cpu_to_le16((char *)val - (char *)header); 618 memset(val + size - EXT2_XATTR_PAD, 0, 619 EXT2_XATTR_PAD); /* Clear the pad bytes. */ 620 memcpy(val, value, value_len); 621 } 622 } 623 624 skip_replace: 625 if (IS_LAST_ENTRY(ENTRY(header+1))) { 626 /* This block is now empty. */ 627 if (bh && header == HDR(bh)) 628 unlock_buffer(bh); /* we were modifying in-place. */ 629 error = ext2_xattr_set2(inode, bh, NULL); 630 } else { 631 ext2_xattr_rehash(header, here); 632 if (bh && header == HDR(bh)) 633 unlock_buffer(bh); /* we were modifying in-place. */ 634 error = ext2_xattr_set2(inode, bh, header); 635 } 636 637 cleanup: 638 if (!(bh && header == HDR(bh))) 639 kfree(header); 640 brelse(bh); 641 up_write(&EXT2_I(inode)->xattr_sem); 642 643 return error; 644 } 645 646 /* 647 * Second half of ext2_xattr_set(): Update the file system. 648 */ 649 static int 650 ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh, 651 struct ext2_xattr_header *header) 652 { 653 struct super_block *sb = inode->i_sb; 654 struct buffer_head *new_bh = NULL; 655 int error; 656 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode); 657 658 if (header) { 659 new_bh = ext2_xattr_cache_find(inode, header); 660 if (new_bh) { 661 /* We found an identical block in the cache. */ 662 if (new_bh == old_bh) { 663 ea_bdebug(new_bh, "keeping this block"); 664 } else { 665 /* The old block is released after updating 666 the inode. */ 667 ea_bdebug(new_bh, "reusing block"); 668 669 error = dquot_alloc_block(inode, 1); 670 if (error) { 671 unlock_buffer(new_bh); 672 goto cleanup; 673 } 674 le32_add_cpu(&HDR(new_bh)->h_refcount, 1); 675 ea_bdebug(new_bh, "refcount now=%d", 676 le32_to_cpu(HDR(new_bh)->h_refcount)); 677 } 678 unlock_buffer(new_bh); 679 } else if (old_bh && header == HDR(old_bh)) { 680 /* Keep this block. No need to lock the block as we 681 don't need to change the reference count. */ 682 new_bh = old_bh; 683 get_bh(new_bh); 684 ext2_xattr_cache_insert(ea_block_cache, new_bh); 685 } else { 686 /* We need to allocate a new block */ 687 ext2_fsblk_t goal = ext2_group_first_block_no(sb, 688 EXT2_I(inode)->i_block_group); 689 int block = ext2_new_block(inode, goal, &error); 690 if (error) 691 goto cleanup; 692 ea_idebug(inode, "creating block %d", block); 693 694 new_bh = sb_getblk(sb, block); 695 if (unlikely(!new_bh)) { 696 ext2_free_blocks(inode, block, 1); 697 mark_inode_dirty(inode); 698 error = -ENOMEM; 699 goto cleanup; 700 } 701 lock_buffer(new_bh); 702 memcpy(new_bh->b_data, header, new_bh->b_size); 703 set_buffer_uptodate(new_bh); 704 unlock_buffer(new_bh); 705 ext2_xattr_cache_insert(ea_block_cache, new_bh); 706 707 ext2_xattr_update_super_block(sb); 708 } 709 mark_buffer_dirty(new_bh); 710 if (IS_SYNC(inode)) { 711 sync_dirty_buffer(new_bh); 712 error = -EIO; 713 if (buffer_req(new_bh) && !buffer_uptodate(new_bh)) 714 goto cleanup; 715 } 716 } 717 718 /* Update the inode. */ 719 EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0; 720 inode->i_ctime = current_time(inode); 721 if (IS_SYNC(inode)) { 722 error = sync_inode_metadata(inode, 1); 723 /* In case sync failed due to ENOSPC the inode was actually 724 * written (only some dirty data were not) so we just proceed 725 * as if nothing happened and cleanup the unused block */ 726 if (error && error != -ENOSPC) { 727 if (new_bh && new_bh != old_bh) { 728 dquot_free_block_nodirty(inode, 1); 729 mark_inode_dirty(inode); 730 } 731 goto cleanup; 732 } 733 } else 734 mark_inode_dirty(inode); 735 736 error = 0; 737 if (old_bh && old_bh != new_bh) { 738 /* 739 * If there was an old block and we are no longer using it, 740 * release the old block. 741 */ 742 lock_buffer(old_bh); 743 if (HDR(old_bh)->h_refcount == cpu_to_le32(1)) { 744 __u32 hash = le32_to_cpu(HDR(old_bh)->h_hash); 745 746 /* 747 * This must happen under buffer lock for 748 * ext2_xattr_set2() to reliably detect freed block 749 */ 750 mb_cache_entry_delete(ea_block_cache, hash, 751 old_bh->b_blocknr); 752 /* Free the old block. */ 753 ea_bdebug(old_bh, "freeing"); 754 ext2_free_blocks(inode, old_bh->b_blocknr, 1); 755 mark_inode_dirty(inode); 756 /* We let our caller release old_bh, so we 757 * need to duplicate the buffer before. */ 758 get_bh(old_bh); 759 bforget(old_bh); 760 } else { 761 /* Decrement the refcount only. */ 762 le32_add_cpu(&HDR(old_bh)->h_refcount, -1); 763 dquot_free_block_nodirty(inode, 1); 764 mark_inode_dirty(inode); 765 mark_buffer_dirty(old_bh); 766 ea_bdebug(old_bh, "refcount now=%d", 767 le32_to_cpu(HDR(old_bh)->h_refcount)); 768 } 769 unlock_buffer(old_bh); 770 } 771 772 cleanup: 773 brelse(new_bh); 774 775 return error; 776 } 777 778 /* 779 * ext2_xattr_delete_inode() 780 * 781 * Free extended attribute resources associated with this inode. This 782 * is called immediately before an inode is freed. 783 */ 784 void 785 ext2_xattr_delete_inode(struct inode *inode) 786 { 787 struct buffer_head *bh = NULL; 788 struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb); 789 790 down_write(&EXT2_I(inode)->xattr_sem); 791 if (!EXT2_I(inode)->i_file_acl) 792 goto cleanup; 793 794 if (!ext2_data_block_valid(sbi, EXT2_I(inode)->i_file_acl, 0)) { 795 ext2_error(inode->i_sb, "ext2_xattr_delete_inode", 796 "inode %ld: xattr block %d is out of data blocks range", 797 inode->i_ino, EXT2_I(inode)->i_file_acl); 798 goto cleanup; 799 } 800 801 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); 802 if (!bh) { 803 ext2_error(inode->i_sb, "ext2_xattr_delete_inode", 804 "inode %ld: block %d read error", inode->i_ino, 805 EXT2_I(inode)->i_file_acl); 806 goto cleanup; 807 } 808 ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count))); 809 if (!ext2_xattr_header_valid(HDR(bh))) { 810 ext2_error(inode->i_sb, "ext2_xattr_delete_inode", 811 "inode %ld: bad block %d", inode->i_ino, 812 EXT2_I(inode)->i_file_acl); 813 goto cleanup; 814 } 815 lock_buffer(bh); 816 if (HDR(bh)->h_refcount == cpu_to_le32(1)) { 817 __u32 hash = le32_to_cpu(HDR(bh)->h_hash); 818 819 /* 820 * This must happen under buffer lock for ext2_xattr_set2() to 821 * reliably detect freed block 822 */ 823 mb_cache_entry_delete(EA_BLOCK_CACHE(inode), hash, 824 bh->b_blocknr); 825 ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1); 826 get_bh(bh); 827 bforget(bh); 828 unlock_buffer(bh); 829 } else { 830 le32_add_cpu(&HDR(bh)->h_refcount, -1); 831 ea_bdebug(bh, "refcount now=%d", 832 le32_to_cpu(HDR(bh)->h_refcount)); 833 unlock_buffer(bh); 834 mark_buffer_dirty(bh); 835 if (IS_SYNC(inode)) 836 sync_dirty_buffer(bh); 837 dquot_free_block_nodirty(inode, 1); 838 } 839 EXT2_I(inode)->i_file_acl = 0; 840 841 cleanup: 842 brelse(bh); 843 up_write(&EXT2_I(inode)->xattr_sem); 844 } 845 846 /* 847 * ext2_xattr_cache_insert() 848 * 849 * Create a new entry in the extended attribute cache, and insert 850 * it unless such an entry is already in the cache. 851 * 852 * Returns 0, or a negative error number on failure. 853 */ 854 static int 855 ext2_xattr_cache_insert(struct mb_cache *cache, struct buffer_head *bh) 856 { 857 __u32 hash = le32_to_cpu(HDR(bh)->h_hash); 858 int error; 859 860 error = mb_cache_entry_create(cache, GFP_NOFS, hash, bh->b_blocknr, 861 true); 862 if (error) { 863 if (error == -EBUSY) { 864 ea_bdebug(bh, "already in cache (%d cache entries)", 865 atomic_read(&ext2_xattr_cache->c_entry_count)); 866 error = 0; 867 } 868 } else 869 ea_bdebug(bh, "inserting [%x]", (int)hash); 870 return error; 871 } 872 873 /* 874 * ext2_xattr_cmp() 875 * 876 * Compare two extended attribute blocks for equality. 877 * 878 * Returns 0 if the blocks are equal, 1 if they differ, and 879 * a negative error number on errors. 880 */ 881 static int 882 ext2_xattr_cmp(struct ext2_xattr_header *header1, 883 struct ext2_xattr_header *header2) 884 { 885 struct ext2_xattr_entry *entry1, *entry2; 886 887 entry1 = ENTRY(header1+1); 888 entry2 = ENTRY(header2+1); 889 while (!IS_LAST_ENTRY(entry1)) { 890 if (IS_LAST_ENTRY(entry2)) 891 return 1; 892 if (entry1->e_hash != entry2->e_hash || 893 entry1->e_name_index != entry2->e_name_index || 894 entry1->e_name_len != entry2->e_name_len || 895 entry1->e_value_size != entry2->e_value_size || 896 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len)) 897 return 1; 898 if (entry1->e_value_block != 0 || entry2->e_value_block != 0) 899 return -EIO; 900 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs), 901 (char *)header2 + le16_to_cpu(entry2->e_value_offs), 902 le32_to_cpu(entry1->e_value_size))) 903 return 1; 904 905 entry1 = EXT2_XATTR_NEXT(entry1); 906 entry2 = EXT2_XATTR_NEXT(entry2); 907 } 908 if (!IS_LAST_ENTRY(entry2)) 909 return 1; 910 return 0; 911 } 912 913 /* 914 * ext2_xattr_cache_find() 915 * 916 * Find an identical extended attribute block. 917 * 918 * Returns a locked buffer head to the block found, or NULL if such 919 * a block was not found or an error occurred. 920 */ 921 static struct buffer_head * 922 ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header) 923 { 924 __u32 hash = le32_to_cpu(header->h_hash); 925 struct mb_cache_entry *ce; 926 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode); 927 928 if (!header->h_hash) 929 return NULL; /* never share */ 930 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash); 931 again: 932 ce = mb_cache_entry_find_first(ea_block_cache, hash); 933 while (ce) { 934 struct buffer_head *bh; 935 936 bh = sb_bread(inode->i_sb, ce->e_value); 937 if (!bh) { 938 ext2_error(inode->i_sb, "ext2_xattr_cache_find", 939 "inode %ld: block %ld read error", 940 inode->i_ino, (unsigned long) ce->e_value); 941 } else { 942 lock_buffer(bh); 943 /* 944 * We have to be careful about races with freeing or 945 * rehashing of xattr block. Once we hold buffer lock 946 * xattr block's state is stable so we can check 947 * whether the block got freed / rehashed or not. 948 * Since we unhash mbcache entry under buffer lock when 949 * freeing / rehashing xattr block, checking whether 950 * entry is still hashed is reliable. 951 */ 952 if (hlist_bl_unhashed(&ce->e_hash_list)) { 953 mb_cache_entry_put(ea_block_cache, ce); 954 unlock_buffer(bh); 955 brelse(bh); 956 goto again; 957 } else if (le32_to_cpu(HDR(bh)->h_refcount) > 958 EXT2_XATTR_REFCOUNT_MAX) { 959 ea_idebug(inode, "block %ld refcount %d>%d", 960 (unsigned long) ce->e_value, 961 le32_to_cpu(HDR(bh)->h_refcount), 962 EXT2_XATTR_REFCOUNT_MAX); 963 } else if (!ext2_xattr_cmp(header, HDR(bh))) { 964 ea_bdebug(bh, "b_count=%d", 965 atomic_read(&(bh->b_count))); 966 mb_cache_entry_touch(ea_block_cache, ce); 967 mb_cache_entry_put(ea_block_cache, ce); 968 return bh; 969 } 970 unlock_buffer(bh); 971 brelse(bh); 972 } 973 ce = mb_cache_entry_find_next(ea_block_cache, ce); 974 } 975 return NULL; 976 } 977 978 #define NAME_HASH_SHIFT 5 979 #define VALUE_HASH_SHIFT 16 980 981 /* 982 * ext2_xattr_hash_entry() 983 * 984 * Compute the hash of an extended attribute. 985 */ 986 static inline void ext2_xattr_hash_entry(struct ext2_xattr_header *header, 987 struct ext2_xattr_entry *entry) 988 { 989 __u32 hash = 0; 990 char *name = entry->e_name; 991 int n; 992 993 for (n=0; n < entry->e_name_len; n++) { 994 hash = (hash << NAME_HASH_SHIFT) ^ 995 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^ 996 *name++; 997 } 998 999 if (entry->e_value_block == 0 && entry->e_value_size != 0) { 1000 __le32 *value = (__le32 *)((char *)header + 1001 le16_to_cpu(entry->e_value_offs)); 1002 for (n = (le32_to_cpu(entry->e_value_size) + 1003 EXT2_XATTR_ROUND) >> EXT2_XATTR_PAD_BITS; n; n--) { 1004 hash = (hash << VALUE_HASH_SHIFT) ^ 1005 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^ 1006 le32_to_cpu(*value++); 1007 } 1008 } 1009 entry->e_hash = cpu_to_le32(hash); 1010 } 1011 1012 #undef NAME_HASH_SHIFT 1013 #undef VALUE_HASH_SHIFT 1014 1015 #define BLOCK_HASH_SHIFT 16 1016 1017 /* 1018 * ext2_xattr_rehash() 1019 * 1020 * Re-compute the extended attribute hash value after an entry has changed. 1021 */ 1022 static void ext2_xattr_rehash(struct ext2_xattr_header *header, 1023 struct ext2_xattr_entry *entry) 1024 { 1025 struct ext2_xattr_entry *here; 1026 __u32 hash = 0; 1027 1028 ext2_xattr_hash_entry(header, entry); 1029 here = ENTRY(header+1); 1030 while (!IS_LAST_ENTRY(here)) { 1031 if (!here->e_hash) { 1032 /* Block is not shared if an entry's hash value == 0 */ 1033 hash = 0; 1034 break; 1035 } 1036 hash = (hash << BLOCK_HASH_SHIFT) ^ 1037 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^ 1038 le32_to_cpu(here->e_hash); 1039 here = EXT2_XATTR_NEXT(here); 1040 } 1041 header->h_hash = cpu_to_le32(hash); 1042 } 1043 1044 #undef BLOCK_HASH_SHIFT 1045 1046 #define HASH_BUCKET_BITS 10 1047 1048 struct mb_cache *ext2_xattr_create_cache(void) 1049 { 1050 return mb_cache_create(HASH_BUCKET_BITS); 1051 } 1052 1053 void ext2_xattr_destroy_cache(struct mb_cache *cache) 1054 { 1055 if (cache) 1056 mb_cache_destroy(cache); 1057 } 1058