1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * xattr.c 5 * 6 * Copyright (C) 2004, 2008 Oracle. All rights reserved. 7 * 8 * CREDITS: 9 * Lots of code in this file is copy from linux/fs/ext3/xattr.c. 10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de> 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public 14 * License version 2 as published by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 */ 21 22 #include <linux/capability.h> 23 #include <linux/fs.h> 24 #include <linux/types.h> 25 #include <linux/slab.h> 26 #include <linux/highmem.h> 27 #include <linux/pagemap.h> 28 #include <linux/uio.h> 29 #include <linux/sched.h> 30 #include <linux/splice.h> 31 #include <linux/mount.h> 32 #include <linux/writeback.h> 33 #include <linux/falloc.h> 34 #include <linux/sort.h> 35 #include <linux/init.h> 36 #include <linux/module.h> 37 #include <linux/string.h> 38 39 #define MLOG_MASK_PREFIX ML_XATTR 40 #include <cluster/masklog.h> 41 42 #include "ocfs2.h" 43 #include "alloc.h" 44 #include "dlmglue.h" 45 #include "file.h" 46 #include "symlink.h" 47 #include "sysfile.h" 48 #include "inode.h" 49 #include "journal.h" 50 #include "ocfs2_fs.h" 51 #include "suballoc.h" 52 #include "uptodate.h" 53 #include "buffer_head_io.h" 54 #include "super.h" 55 #include "xattr.h" 56 57 58 struct ocfs2_xattr_def_value_root { 59 struct ocfs2_xattr_value_root xv; 60 struct ocfs2_extent_rec er; 61 }; 62 63 struct ocfs2_xattr_bucket { 64 struct buffer_head *bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET]; 65 struct ocfs2_xattr_header *xh; 66 }; 67 68 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root)) 69 #define OCFS2_XATTR_INLINE_SIZE 80 70 71 static struct ocfs2_xattr_def_value_root def_xv = { 72 .xv.xr_list.l_count = cpu_to_le16(1), 73 }; 74 75 struct xattr_handler *ocfs2_xattr_handlers[] = { 76 &ocfs2_xattr_user_handler, 77 &ocfs2_xattr_trusted_handler, 78 NULL 79 }; 80 81 static struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = { 82 [OCFS2_XATTR_INDEX_USER] = &ocfs2_xattr_user_handler, 83 [OCFS2_XATTR_INDEX_TRUSTED] = &ocfs2_xattr_trusted_handler, 84 }; 85 86 struct ocfs2_xattr_info { 87 int name_index; 88 const char *name; 89 const void *value; 90 size_t value_len; 91 }; 92 93 struct ocfs2_xattr_search { 94 struct buffer_head *inode_bh; 95 /* 96 * xattr_bh point to the block buffer head which has extended attribute 97 * when extended attribute in inode, xattr_bh is equal to inode_bh. 98 */ 99 struct buffer_head *xattr_bh; 100 struct ocfs2_xattr_header *header; 101 struct ocfs2_xattr_bucket bucket; 102 void *base; 103 void *end; 104 struct ocfs2_xattr_entry *here; 105 int not_found; 106 }; 107 108 static int ocfs2_xattr_bucket_get_name_value(struct inode *inode, 109 struct ocfs2_xattr_header *xh, 110 int index, 111 int *block_off, 112 int *new_offset); 113 114 static int ocfs2_xattr_block_find(struct inode *inode, 115 int name_index, 116 const char *name, 117 struct ocfs2_xattr_search *xs); 118 static int ocfs2_xattr_index_block_find(struct inode *inode, 119 struct buffer_head *root_bh, 120 int name_index, 121 const char *name, 122 struct ocfs2_xattr_search *xs); 123 124 static int ocfs2_xattr_tree_list_index_block(struct inode *inode, 125 struct ocfs2_xattr_tree_root *xt, 126 char *buffer, 127 size_t buffer_size); 128 129 static int ocfs2_xattr_create_index_block(struct inode *inode, 130 struct ocfs2_xattr_search *xs); 131 132 static int ocfs2_xattr_set_entry_index_block(struct inode *inode, 133 struct ocfs2_xattr_info *xi, 134 struct ocfs2_xattr_search *xs); 135 136 static int ocfs2_delete_xattr_index_block(struct inode *inode, 137 struct buffer_head *xb_bh); 138 139 static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb) 140 { 141 return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE; 142 } 143 144 static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb) 145 { 146 return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits); 147 } 148 149 static inline u16 ocfs2_xattr_max_xe_in_bucket(struct super_block *sb) 150 { 151 u16 len = sb->s_blocksize - 152 offsetof(struct ocfs2_xattr_header, xh_entries); 153 154 return len / sizeof(struct ocfs2_xattr_entry); 155 } 156 157 static inline const char *ocfs2_xattr_prefix(int name_index) 158 { 159 struct xattr_handler *handler = NULL; 160 161 if (name_index > 0 && name_index < OCFS2_XATTR_MAX) 162 handler = ocfs2_xattr_handler_map[name_index]; 163 164 return handler ? handler->prefix : NULL; 165 } 166 167 static u32 ocfs2_xattr_name_hash(struct inode *inode, 168 const char *name, 169 int name_len) 170 { 171 /* Get hash value of uuid from super block */ 172 u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash; 173 int i; 174 175 /* hash extended attribute name */ 176 for (i = 0; i < name_len; i++) { 177 hash = (hash << OCFS2_HASH_SHIFT) ^ 178 (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^ 179 *name++; 180 } 181 182 return hash; 183 } 184 185 /* 186 * ocfs2_xattr_hash_entry() 187 * 188 * Compute the hash of an extended attribute. 189 */ 190 static void ocfs2_xattr_hash_entry(struct inode *inode, 191 struct ocfs2_xattr_header *header, 192 struct ocfs2_xattr_entry *entry) 193 { 194 u32 hash = 0; 195 char *name = (char *)header + le16_to_cpu(entry->xe_name_offset); 196 197 hash = ocfs2_xattr_name_hash(inode, name, entry->xe_name_len); 198 entry->xe_name_hash = cpu_to_le32(hash); 199 200 return; 201 } 202 203 static int ocfs2_xattr_extend_allocation(struct inode *inode, 204 u32 clusters_to_add, 205 struct buffer_head *xattr_bh, 206 struct ocfs2_xattr_value_root *xv) 207 { 208 int status = 0; 209 int restart_func = 0; 210 int credits = 0; 211 handle_t *handle = NULL; 212 struct ocfs2_alloc_context *data_ac = NULL; 213 struct ocfs2_alloc_context *meta_ac = NULL; 214 enum ocfs2_alloc_restarted why; 215 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 216 u32 prev_clusters, logical_start = le32_to_cpu(xv->xr_clusters); 217 struct ocfs2_extent_tree et; 218 219 mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add); 220 221 ocfs2_init_xattr_value_extent_tree(&et, inode, xattr_bh, xv); 222 223 restart_all: 224 225 status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0, 226 &data_ac, &meta_ac); 227 if (status) { 228 mlog_errno(status); 229 goto leave; 230 } 231 232 credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el, 233 clusters_to_add); 234 handle = ocfs2_start_trans(osb, credits); 235 if (IS_ERR(handle)) { 236 status = PTR_ERR(handle); 237 handle = NULL; 238 mlog_errno(status); 239 goto leave; 240 } 241 242 restarted_transaction: 243 status = ocfs2_journal_access(handle, inode, xattr_bh, 244 OCFS2_JOURNAL_ACCESS_WRITE); 245 if (status < 0) { 246 mlog_errno(status); 247 goto leave; 248 } 249 250 prev_clusters = le32_to_cpu(xv->xr_clusters); 251 status = ocfs2_add_clusters_in_btree(osb, 252 inode, 253 &logical_start, 254 clusters_to_add, 255 0, 256 &et, 257 handle, 258 data_ac, 259 meta_ac, 260 &why); 261 if ((status < 0) && (status != -EAGAIN)) { 262 if (status != -ENOSPC) 263 mlog_errno(status); 264 goto leave; 265 } 266 267 status = ocfs2_journal_dirty(handle, xattr_bh); 268 if (status < 0) { 269 mlog_errno(status); 270 goto leave; 271 } 272 273 clusters_to_add -= le32_to_cpu(xv->xr_clusters) - prev_clusters; 274 275 if (why != RESTART_NONE && clusters_to_add) { 276 if (why == RESTART_META) { 277 mlog(0, "restarting function.\n"); 278 restart_func = 1; 279 } else { 280 BUG_ON(why != RESTART_TRANS); 281 282 mlog(0, "restarting transaction.\n"); 283 /* TODO: This can be more intelligent. */ 284 credits = ocfs2_calc_extend_credits(osb->sb, 285 et.et_root_el, 286 clusters_to_add); 287 status = ocfs2_extend_trans(handle, credits); 288 if (status < 0) { 289 /* handle still has to be committed at 290 * this point. */ 291 status = -ENOMEM; 292 mlog_errno(status); 293 goto leave; 294 } 295 goto restarted_transaction; 296 } 297 } 298 299 leave: 300 if (handle) { 301 ocfs2_commit_trans(osb, handle); 302 handle = NULL; 303 } 304 if (data_ac) { 305 ocfs2_free_alloc_context(data_ac); 306 data_ac = NULL; 307 } 308 if (meta_ac) { 309 ocfs2_free_alloc_context(meta_ac); 310 meta_ac = NULL; 311 } 312 if ((!status) && restart_func) { 313 restart_func = 0; 314 goto restart_all; 315 } 316 317 return status; 318 } 319 320 static int __ocfs2_remove_xattr_range(struct inode *inode, 321 struct buffer_head *root_bh, 322 struct ocfs2_xattr_value_root *xv, 323 u32 cpos, u32 phys_cpos, u32 len, 324 struct ocfs2_cached_dealloc_ctxt *dealloc) 325 { 326 int ret; 327 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); 328 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 329 struct inode *tl_inode = osb->osb_tl_inode; 330 handle_t *handle; 331 struct ocfs2_alloc_context *meta_ac = NULL; 332 struct ocfs2_extent_tree et; 333 334 ocfs2_init_xattr_value_extent_tree(&et, inode, root_bh, xv); 335 336 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac); 337 if (ret) { 338 mlog_errno(ret); 339 return ret; 340 } 341 342 mutex_lock(&tl_inode->i_mutex); 343 344 if (ocfs2_truncate_log_needs_flush(osb)) { 345 ret = __ocfs2_flush_truncate_log(osb); 346 if (ret < 0) { 347 mlog_errno(ret); 348 goto out; 349 } 350 } 351 352 handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS); 353 if (IS_ERR(handle)) { 354 ret = PTR_ERR(handle); 355 mlog_errno(ret); 356 goto out; 357 } 358 359 ret = ocfs2_journal_access(handle, inode, root_bh, 360 OCFS2_JOURNAL_ACCESS_WRITE); 361 if (ret) { 362 mlog_errno(ret); 363 goto out_commit; 364 } 365 366 ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac, 367 dealloc); 368 if (ret) { 369 mlog_errno(ret); 370 goto out_commit; 371 } 372 373 le32_add_cpu(&xv->xr_clusters, -len); 374 375 ret = ocfs2_journal_dirty(handle, root_bh); 376 if (ret) { 377 mlog_errno(ret); 378 goto out_commit; 379 } 380 381 ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len); 382 if (ret) 383 mlog_errno(ret); 384 385 out_commit: 386 ocfs2_commit_trans(osb, handle); 387 out: 388 mutex_unlock(&tl_inode->i_mutex); 389 390 if (meta_ac) 391 ocfs2_free_alloc_context(meta_ac); 392 393 return ret; 394 } 395 396 static int ocfs2_xattr_shrink_size(struct inode *inode, 397 u32 old_clusters, 398 u32 new_clusters, 399 struct buffer_head *root_bh, 400 struct ocfs2_xattr_value_root *xv) 401 { 402 int ret = 0; 403 u32 trunc_len, cpos, phys_cpos, alloc_size; 404 u64 block; 405 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 406 struct ocfs2_cached_dealloc_ctxt dealloc; 407 408 ocfs2_init_dealloc_ctxt(&dealloc); 409 410 if (old_clusters <= new_clusters) 411 return 0; 412 413 cpos = new_clusters; 414 trunc_len = old_clusters - new_clusters; 415 while (trunc_len) { 416 ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos, 417 &alloc_size, &xv->xr_list); 418 if (ret) { 419 mlog_errno(ret); 420 goto out; 421 } 422 423 if (alloc_size > trunc_len) 424 alloc_size = trunc_len; 425 426 ret = __ocfs2_remove_xattr_range(inode, root_bh, xv, cpos, 427 phys_cpos, alloc_size, 428 &dealloc); 429 if (ret) { 430 mlog_errno(ret); 431 goto out; 432 } 433 434 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); 435 ocfs2_remove_xattr_clusters_from_cache(inode, block, 436 alloc_size); 437 cpos += alloc_size; 438 trunc_len -= alloc_size; 439 } 440 441 out: 442 ocfs2_schedule_truncate_log_flush(osb, 1); 443 ocfs2_run_deallocs(osb, &dealloc); 444 445 return ret; 446 } 447 448 static int ocfs2_xattr_value_truncate(struct inode *inode, 449 struct buffer_head *root_bh, 450 struct ocfs2_xattr_value_root *xv, 451 int len) 452 { 453 int ret; 454 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len); 455 u32 old_clusters = le32_to_cpu(xv->xr_clusters); 456 457 if (new_clusters == old_clusters) 458 return 0; 459 460 if (new_clusters > old_clusters) 461 ret = ocfs2_xattr_extend_allocation(inode, 462 new_clusters - old_clusters, 463 root_bh, xv); 464 else 465 ret = ocfs2_xattr_shrink_size(inode, 466 old_clusters, new_clusters, 467 root_bh, xv); 468 469 return ret; 470 } 471 472 static int ocfs2_xattr_list_entry(char *buffer, size_t size, 473 size_t *result, const char *prefix, 474 const char *name, int name_len) 475 { 476 char *p = buffer + *result; 477 int prefix_len = strlen(prefix); 478 int total_len = prefix_len + name_len + 1; 479 480 *result += total_len; 481 482 /* we are just looking for how big our buffer needs to be */ 483 if (!size) 484 return 0; 485 486 if (*result > size) 487 return -ERANGE; 488 489 memcpy(p, prefix, prefix_len); 490 memcpy(p + prefix_len, name, name_len); 491 p[prefix_len + name_len] = '\0'; 492 493 return 0; 494 } 495 496 static int ocfs2_xattr_list_entries(struct inode *inode, 497 struct ocfs2_xattr_header *header, 498 char *buffer, size_t buffer_size) 499 { 500 size_t result = 0; 501 int i, type, ret; 502 const char *prefix, *name; 503 504 for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) { 505 struct ocfs2_xattr_entry *entry = &header->xh_entries[i]; 506 type = ocfs2_xattr_get_type(entry); 507 prefix = ocfs2_xattr_prefix(type); 508 509 if (prefix) { 510 name = (const char *)header + 511 le16_to_cpu(entry->xe_name_offset); 512 513 ret = ocfs2_xattr_list_entry(buffer, buffer_size, 514 &result, prefix, name, 515 entry->xe_name_len); 516 if (ret) 517 return ret; 518 } 519 } 520 521 return result; 522 } 523 524 static int ocfs2_xattr_ibody_list(struct inode *inode, 525 struct ocfs2_dinode *di, 526 char *buffer, 527 size_t buffer_size) 528 { 529 struct ocfs2_xattr_header *header = NULL; 530 struct ocfs2_inode_info *oi = OCFS2_I(inode); 531 int ret = 0; 532 533 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) 534 return ret; 535 536 header = (struct ocfs2_xattr_header *) 537 ((void *)di + inode->i_sb->s_blocksize - 538 le16_to_cpu(di->i_xattr_inline_size)); 539 540 ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size); 541 542 return ret; 543 } 544 545 static int ocfs2_xattr_block_list(struct inode *inode, 546 struct ocfs2_dinode *di, 547 char *buffer, 548 size_t buffer_size) 549 { 550 struct buffer_head *blk_bh = NULL; 551 struct ocfs2_xattr_block *xb; 552 int ret = 0; 553 554 if (!di->i_xattr_loc) 555 return ret; 556 557 ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh); 558 if (ret < 0) { 559 mlog_errno(ret); 560 return ret; 561 } 562 563 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 564 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) { 565 ret = -EIO; 566 goto cleanup; 567 } 568 569 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 570 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header; 571 ret = ocfs2_xattr_list_entries(inode, header, 572 buffer, buffer_size); 573 } else { 574 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root; 575 ret = ocfs2_xattr_tree_list_index_block(inode, xt, 576 buffer, buffer_size); 577 } 578 cleanup: 579 brelse(blk_bh); 580 581 return ret; 582 } 583 584 ssize_t ocfs2_listxattr(struct dentry *dentry, 585 char *buffer, 586 size_t size) 587 { 588 int ret = 0, i_ret = 0, b_ret = 0; 589 struct buffer_head *di_bh = NULL; 590 struct ocfs2_dinode *di = NULL; 591 struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode); 592 593 if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb))) 594 return -EOPNOTSUPP; 595 596 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 597 return ret; 598 599 ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0); 600 if (ret < 0) { 601 mlog_errno(ret); 602 return ret; 603 } 604 605 di = (struct ocfs2_dinode *)di_bh->b_data; 606 607 down_read(&oi->ip_xattr_sem); 608 i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size); 609 if (i_ret < 0) 610 b_ret = 0; 611 else { 612 if (buffer) { 613 buffer += i_ret; 614 size -= i_ret; 615 } 616 b_ret = ocfs2_xattr_block_list(dentry->d_inode, di, 617 buffer, size); 618 if (b_ret < 0) 619 i_ret = 0; 620 } 621 up_read(&oi->ip_xattr_sem); 622 ocfs2_inode_unlock(dentry->d_inode, 0); 623 624 brelse(di_bh); 625 626 return i_ret + b_ret; 627 } 628 629 static int ocfs2_xattr_find_entry(int name_index, 630 const char *name, 631 struct ocfs2_xattr_search *xs) 632 { 633 struct ocfs2_xattr_entry *entry; 634 size_t name_len; 635 int i, cmp = 1; 636 637 if (name == NULL) 638 return -EINVAL; 639 640 name_len = strlen(name); 641 entry = xs->here; 642 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) { 643 cmp = name_index - ocfs2_xattr_get_type(entry); 644 if (!cmp) 645 cmp = name_len - entry->xe_name_len; 646 if (!cmp) 647 cmp = memcmp(name, (xs->base + 648 le16_to_cpu(entry->xe_name_offset)), 649 name_len); 650 if (cmp == 0) 651 break; 652 entry += 1; 653 } 654 xs->here = entry; 655 656 return cmp ? -ENODATA : 0; 657 } 658 659 static int ocfs2_xattr_get_value_outside(struct inode *inode, 660 struct ocfs2_xattr_value_root *xv, 661 void *buffer, 662 size_t len) 663 { 664 u32 cpos, p_cluster, num_clusters, bpc, clusters; 665 u64 blkno; 666 int i, ret = 0; 667 size_t cplen, blocksize; 668 struct buffer_head *bh = NULL; 669 struct ocfs2_extent_list *el; 670 671 el = &xv->xr_list; 672 clusters = le32_to_cpu(xv->xr_clusters); 673 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 674 blocksize = inode->i_sb->s_blocksize; 675 676 cpos = 0; 677 while (cpos < clusters) { 678 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster, 679 &num_clusters, el); 680 if (ret) { 681 mlog_errno(ret); 682 goto out; 683 } 684 685 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); 686 /* Copy ocfs2_xattr_value */ 687 for (i = 0; i < num_clusters * bpc; i++, blkno++) { 688 ret = ocfs2_read_block(inode, blkno, &bh); 689 if (ret) { 690 mlog_errno(ret); 691 goto out; 692 } 693 694 cplen = len >= blocksize ? blocksize : len; 695 memcpy(buffer, bh->b_data, cplen); 696 len -= cplen; 697 buffer += cplen; 698 699 brelse(bh); 700 bh = NULL; 701 if (len == 0) 702 break; 703 } 704 cpos += num_clusters; 705 } 706 out: 707 return ret; 708 } 709 710 static int ocfs2_xattr_ibody_get(struct inode *inode, 711 int name_index, 712 const char *name, 713 void *buffer, 714 size_t buffer_size, 715 struct ocfs2_xattr_search *xs) 716 { 717 struct ocfs2_inode_info *oi = OCFS2_I(inode); 718 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 719 struct ocfs2_xattr_value_root *xv; 720 size_t size; 721 int ret = 0; 722 723 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) 724 return -ENODATA; 725 726 xs->end = (void *)di + inode->i_sb->s_blocksize; 727 xs->header = (struct ocfs2_xattr_header *) 728 (xs->end - le16_to_cpu(di->i_xattr_inline_size)); 729 xs->base = (void *)xs->header; 730 xs->here = xs->header->xh_entries; 731 732 ret = ocfs2_xattr_find_entry(name_index, name, xs); 733 if (ret) 734 return ret; 735 size = le64_to_cpu(xs->here->xe_value_size); 736 if (buffer) { 737 if (size > buffer_size) 738 return -ERANGE; 739 if (ocfs2_xattr_is_local(xs->here)) { 740 memcpy(buffer, (void *)xs->base + 741 le16_to_cpu(xs->here->xe_name_offset) + 742 OCFS2_XATTR_SIZE(xs->here->xe_name_len), size); 743 } else { 744 xv = (struct ocfs2_xattr_value_root *) 745 (xs->base + le16_to_cpu( 746 xs->here->xe_name_offset) + 747 OCFS2_XATTR_SIZE(xs->here->xe_name_len)); 748 ret = ocfs2_xattr_get_value_outside(inode, xv, 749 buffer, size); 750 if (ret < 0) { 751 mlog_errno(ret); 752 return ret; 753 } 754 } 755 } 756 757 return size; 758 } 759 760 static int ocfs2_xattr_block_get(struct inode *inode, 761 int name_index, 762 const char *name, 763 void *buffer, 764 size_t buffer_size, 765 struct ocfs2_xattr_search *xs) 766 { 767 struct ocfs2_xattr_block *xb; 768 struct ocfs2_xattr_value_root *xv; 769 size_t size; 770 int ret = -ENODATA, name_offset, name_len, block_off, i; 771 772 memset(&xs->bucket, 0, sizeof(xs->bucket)); 773 774 ret = ocfs2_xattr_block_find(inode, name_index, name, xs); 775 if (ret) { 776 mlog_errno(ret); 777 goto cleanup; 778 } 779 780 xb = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data; 781 size = le64_to_cpu(xs->here->xe_value_size); 782 if (buffer) { 783 ret = -ERANGE; 784 if (size > buffer_size) 785 goto cleanup; 786 787 name_offset = le16_to_cpu(xs->here->xe_name_offset); 788 name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len); 789 i = xs->here - xs->header->xh_entries; 790 791 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) { 792 ret = ocfs2_xattr_bucket_get_name_value(inode, 793 xs->bucket.xh, 794 i, 795 &block_off, 796 &name_offset); 797 xs->base = xs->bucket.bhs[block_off]->b_data; 798 } 799 if (ocfs2_xattr_is_local(xs->here)) { 800 memcpy(buffer, (void *)xs->base + 801 name_offset + name_len, size); 802 } else { 803 xv = (struct ocfs2_xattr_value_root *) 804 (xs->base + name_offset + name_len); 805 ret = ocfs2_xattr_get_value_outside(inode, xv, 806 buffer, size); 807 if (ret < 0) { 808 mlog_errno(ret); 809 goto cleanup; 810 } 811 } 812 } 813 ret = size; 814 cleanup: 815 for (i = 0; i < OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET; i++) 816 brelse(xs->bucket.bhs[i]); 817 memset(&xs->bucket, 0, sizeof(xs->bucket)); 818 819 brelse(xs->xattr_bh); 820 xs->xattr_bh = NULL; 821 return ret; 822 } 823 824 /* ocfs2_xattr_get() 825 * 826 * Copy an extended attribute into the buffer provided. 827 * Buffer is NULL to compute the size of buffer required. 828 */ 829 static int ocfs2_xattr_get(struct inode *inode, 830 int name_index, 831 const char *name, 832 void *buffer, 833 size_t buffer_size) 834 { 835 int ret; 836 struct ocfs2_dinode *di = NULL; 837 struct buffer_head *di_bh = NULL; 838 struct ocfs2_inode_info *oi = OCFS2_I(inode); 839 struct ocfs2_xattr_search xis = { 840 .not_found = -ENODATA, 841 }; 842 struct ocfs2_xattr_search xbs = { 843 .not_found = -ENODATA, 844 }; 845 846 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 847 return -EOPNOTSUPP; 848 849 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 850 ret = -ENODATA; 851 852 ret = ocfs2_inode_lock(inode, &di_bh, 0); 853 if (ret < 0) { 854 mlog_errno(ret); 855 return ret; 856 } 857 xis.inode_bh = xbs.inode_bh = di_bh; 858 di = (struct ocfs2_dinode *)di_bh->b_data; 859 860 down_read(&oi->ip_xattr_sem); 861 ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer, 862 buffer_size, &xis); 863 if (ret == -ENODATA) 864 ret = ocfs2_xattr_block_get(inode, name_index, name, buffer, 865 buffer_size, &xbs); 866 up_read(&oi->ip_xattr_sem); 867 ocfs2_inode_unlock(inode, 0); 868 869 brelse(di_bh); 870 871 return ret; 872 } 873 874 static int __ocfs2_xattr_set_value_outside(struct inode *inode, 875 struct ocfs2_xattr_value_root *xv, 876 const void *value, 877 int value_len) 878 { 879 int ret = 0, i, cp_len, credits; 880 u16 blocksize = inode->i_sb->s_blocksize; 881 u32 p_cluster, num_clusters; 882 u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 883 u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len); 884 u64 blkno; 885 struct buffer_head *bh = NULL; 886 handle_t *handle; 887 888 BUG_ON(clusters > le32_to_cpu(xv->xr_clusters)); 889 890 credits = clusters * bpc; 891 handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), credits); 892 if (IS_ERR(handle)) { 893 ret = PTR_ERR(handle); 894 mlog_errno(ret); 895 goto out; 896 } 897 898 while (cpos < clusters) { 899 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster, 900 &num_clusters, &xv->xr_list); 901 if (ret) { 902 mlog_errno(ret); 903 goto out_commit; 904 } 905 906 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); 907 908 for (i = 0; i < num_clusters * bpc; i++, blkno++) { 909 ret = ocfs2_read_block(inode, blkno, &bh); 910 if (ret) { 911 mlog_errno(ret); 912 goto out_commit; 913 } 914 915 ret = ocfs2_journal_access(handle, 916 inode, 917 bh, 918 OCFS2_JOURNAL_ACCESS_WRITE); 919 if (ret < 0) { 920 mlog_errno(ret); 921 goto out_commit; 922 } 923 924 cp_len = value_len > blocksize ? blocksize : value_len; 925 memcpy(bh->b_data, value, cp_len); 926 value_len -= cp_len; 927 value += cp_len; 928 if (cp_len < blocksize) 929 memset(bh->b_data + cp_len, 0, 930 blocksize - cp_len); 931 932 ret = ocfs2_journal_dirty(handle, bh); 933 if (ret < 0) { 934 mlog_errno(ret); 935 goto out_commit; 936 } 937 brelse(bh); 938 bh = NULL; 939 940 /* 941 * XXX: do we need to empty all the following 942 * blocks in this cluster? 943 */ 944 if (!value_len) 945 break; 946 } 947 cpos += num_clusters; 948 } 949 out_commit: 950 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 951 out: 952 brelse(bh); 953 954 return ret; 955 } 956 957 static int ocfs2_xattr_cleanup(struct inode *inode, 958 struct ocfs2_xattr_info *xi, 959 struct ocfs2_xattr_search *xs, 960 size_t offs) 961 { 962 handle_t *handle = NULL; 963 int ret = 0; 964 size_t name_len = strlen(xi->name); 965 void *val = xs->base + offs; 966 size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE; 967 968 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 969 OCFS2_XATTR_BLOCK_UPDATE_CREDITS); 970 if (IS_ERR(handle)) { 971 ret = PTR_ERR(handle); 972 mlog_errno(ret); 973 goto out; 974 } 975 ret = ocfs2_journal_access(handle, inode, xs->xattr_bh, 976 OCFS2_JOURNAL_ACCESS_WRITE); 977 if (ret) { 978 mlog_errno(ret); 979 goto out_commit; 980 } 981 /* Decrease xattr count */ 982 le16_add_cpu(&xs->header->xh_count, -1); 983 /* Remove the xattr entry and tree root which has already be set*/ 984 memset((void *)xs->here, 0, sizeof(struct ocfs2_xattr_entry)); 985 memset(val, 0, size); 986 987 ret = ocfs2_journal_dirty(handle, xs->xattr_bh); 988 if (ret < 0) 989 mlog_errno(ret); 990 out_commit: 991 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 992 out: 993 return ret; 994 } 995 996 static int ocfs2_xattr_update_entry(struct inode *inode, 997 struct ocfs2_xattr_info *xi, 998 struct ocfs2_xattr_search *xs, 999 size_t offs) 1000 { 1001 handle_t *handle = NULL; 1002 int ret = 0; 1003 1004 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1005 OCFS2_XATTR_BLOCK_UPDATE_CREDITS); 1006 if (IS_ERR(handle)) { 1007 ret = PTR_ERR(handle); 1008 mlog_errno(ret); 1009 goto out; 1010 } 1011 ret = ocfs2_journal_access(handle, inode, xs->xattr_bh, 1012 OCFS2_JOURNAL_ACCESS_WRITE); 1013 if (ret) { 1014 mlog_errno(ret); 1015 goto out_commit; 1016 } 1017 1018 xs->here->xe_name_offset = cpu_to_le16(offs); 1019 xs->here->xe_value_size = cpu_to_le64(xi->value_len); 1020 if (xi->value_len <= OCFS2_XATTR_INLINE_SIZE) 1021 ocfs2_xattr_set_local(xs->here, 1); 1022 else 1023 ocfs2_xattr_set_local(xs->here, 0); 1024 ocfs2_xattr_hash_entry(inode, xs->header, xs->here); 1025 1026 ret = ocfs2_journal_dirty(handle, xs->xattr_bh); 1027 if (ret < 0) 1028 mlog_errno(ret); 1029 out_commit: 1030 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 1031 out: 1032 return ret; 1033 } 1034 1035 /* 1036 * ocfs2_xattr_set_value_outside() 1037 * 1038 * Set large size value in B tree. 1039 */ 1040 static int ocfs2_xattr_set_value_outside(struct inode *inode, 1041 struct ocfs2_xattr_info *xi, 1042 struct ocfs2_xattr_search *xs, 1043 size_t offs) 1044 { 1045 size_t name_len = strlen(xi->name); 1046 void *val = xs->base + offs; 1047 struct ocfs2_xattr_value_root *xv = NULL; 1048 size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE; 1049 int ret = 0; 1050 1051 memset(val, 0, size); 1052 memcpy(val, xi->name, name_len); 1053 xv = (struct ocfs2_xattr_value_root *) 1054 (val + OCFS2_XATTR_SIZE(name_len)); 1055 xv->xr_clusters = 0; 1056 xv->xr_last_eb_blk = 0; 1057 xv->xr_list.l_tree_depth = 0; 1058 xv->xr_list.l_count = cpu_to_le16(1); 1059 xv->xr_list.l_next_free_rec = 0; 1060 1061 ret = ocfs2_xattr_value_truncate(inode, xs->xattr_bh, xv, 1062 xi->value_len); 1063 if (ret < 0) { 1064 mlog_errno(ret); 1065 return ret; 1066 } 1067 ret = __ocfs2_xattr_set_value_outside(inode, xv, xi->value, 1068 xi->value_len); 1069 if (ret < 0) { 1070 mlog_errno(ret); 1071 return ret; 1072 } 1073 ret = ocfs2_xattr_update_entry(inode, xi, xs, offs); 1074 if (ret < 0) 1075 mlog_errno(ret); 1076 1077 return ret; 1078 } 1079 1080 /* 1081 * ocfs2_xattr_set_entry_local() 1082 * 1083 * Set, replace or remove extended attribute in local. 1084 */ 1085 static void ocfs2_xattr_set_entry_local(struct inode *inode, 1086 struct ocfs2_xattr_info *xi, 1087 struct ocfs2_xattr_search *xs, 1088 struct ocfs2_xattr_entry *last, 1089 size_t min_offs) 1090 { 1091 size_t name_len = strlen(xi->name); 1092 int i; 1093 1094 if (xi->value && xs->not_found) { 1095 /* Insert the new xattr entry. */ 1096 le16_add_cpu(&xs->header->xh_count, 1); 1097 ocfs2_xattr_set_type(last, xi->name_index); 1098 ocfs2_xattr_set_local(last, 1); 1099 last->xe_name_len = name_len; 1100 } else { 1101 void *first_val; 1102 void *val; 1103 size_t offs, size; 1104 1105 first_val = xs->base + min_offs; 1106 offs = le16_to_cpu(xs->here->xe_name_offset); 1107 val = xs->base + offs; 1108 1109 if (le64_to_cpu(xs->here->xe_value_size) > 1110 OCFS2_XATTR_INLINE_SIZE) 1111 size = OCFS2_XATTR_SIZE(name_len) + 1112 OCFS2_XATTR_ROOT_SIZE; 1113 else 1114 size = OCFS2_XATTR_SIZE(name_len) + 1115 OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size)); 1116 1117 if (xi->value && size == OCFS2_XATTR_SIZE(name_len) + 1118 OCFS2_XATTR_SIZE(xi->value_len)) { 1119 /* The old and the new value have the 1120 same size. Just replace the value. */ 1121 ocfs2_xattr_set_local(xs->here, 1); 1122 xs->here->xe_value_size = cpu_to_le64(xi->value_len); 1123 /* Clear value bytes. */ 1124 memset(val + OCFS2_XATTR_SIZE(name_len), 1125 0, 1126 OCFS2_XATTR_SIZE(xi->value_len)); 1127 memcpy(val + OCFS2_XATTR_SIZE(name_len), 1128 xi->value, 1129 xi->value_len); 1130 return; 1131 } 1132 /* Remove the old name+value. */ 1133 memmove(first_val + size, first_val, val - first_val); 1134 memset(first_val, 0, size); 1135 xs->here->xe_name_hash = 0; 1136 xs->here->xe_name_offset = 0; 1137 ocfs2_xattr_set_local(xs->here, 1); 1138 xs->here->xe_value_size = 0; 1139 1140 min_offs += size; 1141 1142 /* Adjust all value offsets. */ 1143 last = xs->header->xh_entries; 1144 for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) { 1145 size_t o = le16_to_cpu(last->xe_name_offset); 1146 1147 if (o < offs) 1148 last->xe_name_offset = cpu_to_le16(o + size); 1149 last += 1; 1150 } 1151 1152 if (!xi->value) { 1153 /* Remove the old entry. */ 1154 last -= 1; 1155 memmove(xs->here, xs->here + 1, 1156 (void *)last - (void *)xs->here); 1157 memset(last, 0, sizeof(struct ocfs2_xattr_entry)); 1158 le16_add_cpu(&xs->header->xh_count, -1); 1159 } 1160 } 1161 if (xi->value) { 1162 /* Insert the new name+value. */ 1163 size_t size = OCFS2_XATTR_SIZE(name_len) + 1164 OCFS2_XATTR_SIZE(xi->value_len); 1165 void *val = xs->base + min_offs - size; 1166 1167 xs->here->xe_name_offset = cpu_to_le16(min_offs - size); 1168 memset(val, 0, size); 1169 memcpy(val, xi->name, name_len); 1170 memcpy(val + OCFS2_XATTR_SIZE(name_len), 1171 xi->value, 1172 xi->value_len); 1173 xs->here->xe_value_size = cpu_to_le64(xi->value_len); 1174 ocfs2_xattr_set_local(xs->here, 1); 1175 ocfs2_xattr_hash_entry(inode, xs->header, xs->here); 1176 } 1177 1178 return; 1179 } 1180 1181 /* 1182 * ocfs2_xattr_set_entry() 1183 * 1184 * Set extended attribute entry into inode or block. 1185 * 1186 * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE, 1187 * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(), 1188 * then set value in B tree with set_value_outside(). 1189 */ 1190 static int ocfs2_xattr_set_entry(struct inode *inode, 1191 struct ocfs2_xattr_info *xi, 1192 struct ocfs2_xattr_search *xs, 1193 int flag) 1194 { 1195 struct ocfs2_xattr_entry *last; 1196 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1197 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1198 size_t min_offs = xs->end - xs->base, name_len = strlen(xi->name); 1199 size_t size_l = 0; 1200 handle_t *handle = NULL; 1201 int free, i, ret; 1202 struct ocfs2_xattr_info xi_l = { 1203 .name_index = xi->name_index, 1204 .name = xi->name, 1205 .value = xi->value, 1206 .value_len = xi->value_len, 1207 }; 1208 1209 /* Compute min_offs, last and free space. */ 1210 last = xs->header->xh_entries; 1211 1212 for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) { 1213 size_t offs = le16_to_cpu(last->xe_name_offset); 1214 if (offs < min_offs) 1215 min_offs = offs; 1216 last += 1; 1217 } 1218 1219 free = min_offs - ((void *)last - xs->base) - sizeof(__u32); 1220 if (free < 0) 1221 return -EIO; 1222 1223 if (!xs->not_found) { 1224 size_t size = 0; 1225 if (ocfs2_xattr_is_local(xs->here)) 1226 size = OCFS2_XATTR_SIZE(name_len) + 1227 OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size)); 1228 else 1229 size = OCFS2_XATTR_SIZE(name_len) + 1230 OCFS2_XATTR_ROOT_SIZE; 1231 free += (size + sizeof(struct ocfs2_xattr_entry)); 1232 } 1233 /* Check free space in inode or block */ 1234 if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) { 1235 if (free < sizeof(struct ocfs2_xattr_entry) + 1236 OCFS2_XATTR_SIZE(name_len) + 1237 OCFS2_XATTR_ROOT_SIZE) { 1238 ret = -ENOSPC; 1239 goto out; 1240 } 1241 size_l = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE; 1242 xi_l.value = (void *)&def_xv; 1243 xi_l.value_len = OCFS2_XATTR_ROOT_SIZE; 1244 } else if (xi->value) { 1245 if (free < sizeof(struct ocfs2_xattr_entry) + 1246 OCFS2_XATTR_SIZE(name_len) + 1247 OCFS2_XATTR_SIZE(xi->value_len)) { 1248 ret = -ENOSPC; 1249 goto out; 1250 } 1251 } 1252 1253 if (!xs->not_found) { 1254 /* For existing extended attribute */ 1255 size_t size = OCFS2_XATTR_SIZE(name_len) + 1256 OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size)); 1257 size_t offs = le16_to_cpu(xs->here->xe_name_offset); 1258 void *val = xs->base + offs; 1259 1260 if (ocfs2_xattr_is_local(xs->here) && size == size_l) { 1261 /* Replace existing local xattr with tree root */ 1262 ret = ocfs2_xattr_set_value_outside(inode, xi, xs, 1263 offs); 1264 if (ret < 0) 1265 mlog_errno(ret); 1266 goto out; 1267 } else if (!ocfs2_xattr_is_local(xs->here)) { 1268 /* For existing xattr which has value outside */ 1269 struct ocfs2_xattr_value_root *xv = NULL; 1270 xv = (struct ocfs2_xattr_value_root *)(val + 1271 OCFS2_XATTR_SIZE(name_len)); 1272 1273 if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) { 1274 /* 1275 * If new value need set outside also, 1276 * first truncate old value to new value, 1277 * then set new value with set_value_outside(). 1278 */ 1279 ret = ocfs2_xattr_value_truncate(inode, 1280 xs->xattr_bh, 1281 xv, 1282 xi->value_len); 1283 if (ret < 0) { 1284 mlog_errno(ret); 1285 goto out; 1286 } 1287 1288 ret = __ocfs2_xattr_set_value_outside(inode, 1289 xv, 1290 xi->value, 1291 xi->value_len); 1292 if (ret < 0) { 1293 mlog_errno(ret); 1294 goto out; 1295 } 1296 1297 ret = ocfs2_xattr_update_entry(inode, 1298 xi, 1299 xs, 1300 offs); 1301 if (ret < 0) 1302 mlog_errno(ret); 1303 goto out; 1304 } else { 1305 /* 1306 * If new value need set in local, 1307 * just trucate old value to zero. 1308 */ 1309 ret = ocfs2_xattr_value_truncate(inode, 1310 xs->xattr_bh, 1311 xv, 1312 0); 1313 if (ret < 0) 1314 mlog_errno(ret); 1315 } 1316 } 1317 } 1318 1319 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1320 OCFS2_INODE_UPDATE_CREDITS); 1321 if (IS_ERR(handle)) { 1322 ret = PTR_ERR(handle); 1323 mlog_errno(ret); 1324 goto out; 1325 } 1326 1327 ret = ocfs2_journal_access(handle, inode, xs->inode_bh, 1328 OCFS2_JOURNAL_ACCESS_WRITE); 1329 if (ret) { 1330 mlog_errno(ret); 1331 goto out_commit; 1332 } 1333 1334 if (!(flag & OCFS2_INLINE_XATTR_FL)) { 1335 /* set extended attribute in external block. */ 1336 ret = ocfs2_extend_trans(handle, 1337 OCFS2_INODE_UPDATE_CREDITS + 1338 OCFS2_XATTR_BLOCK_UPDATE_CREDITS); 1339 if (ret) { 1340 mlog_errno(ret); 1341 goto out_commit; 1342 } 1343 ret = ocfs2_journal_access(handle, inode, xs->xattr_bh, 1344 OCFS2_JOURNAL_ACCESS_WRITE); 1345 if (ret) { 1346 mlog_errno(ret); 1347 goto out_commit; 1348 } 1349 } 1350 1351 /* 1352 * Set value in local, include set tree root in local. 1353 * This is the first step for value size >INLINE_SIZE. 1354 */ 1355 ocfs2_xattr_set_entry_local(inode, &xi_l, xs, last, min_offs); 1356 1357 if (!(flag & OCFS2_INLINE_XATTR_FL)) { 1358 ret = ocfs2_journal_dirty(handle, xs->xattr_bh); 1359 if (ret < 0) { 1360 mlog_errno(ret); 1361 goto out_commit; 1362 } 1363 } 1364 1365 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) && 1366 (flag & OCFS2_INLINE_XATTR_FL)) { 1367 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1368 unsigned int xattrsize = osb->s_xattr_inline_size; 1369 1370 /* 1371 * Adjust extent record count or inline data size 1372 * to reserve space for extended attribute. 1373 */ 1374 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1375 struct ocfs2_inline_data *idata = &di->id2.i_data; 1376 le16_add_cpu(&idata->id_count, -xattrsize); 1377 } else if (!(ocfs2_inode_is_fast_symlink(inode))) { 1378 struct ocfs2_extent_list *el = &di->id2.i_list; 1379 le16_add_cpu(&el->l_count, -(xattrsize / 1380 sizeof(struct ocfs2_extent_rec))); 1381 } 1382 di->i_xattr_inline_size = cpu_to_le16(xattrsize); 1383 } 1384 /* Update xattr flag */ 1385 spin_lock(&oi->ip_lock); 1386 oi->ip_dyn_features |= flag; 1387 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 1388 spin_unlock(&oi->ip_lock); 1389 /* Update inode ctime */ 1390 inode->i_ctime = CURRENT_TIME; 1391 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 1392 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 1393 1394 ret = ocfs2_journal_dirty(handle, xs->inode_bh); 1395 if (ret < 0) 1396 mlog_errno(ret); 1397 1398 out_commit: 1399 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 1400 1401 if (!ret && xi->value_len > OCFS2_XATTR_INLINE_SIZE) { 1402 /* 1403 * Set value outside in B tree. 1404 * This is the second step for value size > INLINE_SIZE. 1405 */ 1406 size_t offs = le16_to_cpu(xs->here->xe_name_offset); 1407 ret = ocfs2_xattr_set_value_outside(inode, xi, xs, offs); 1408 if (ret < 0) { 1409 int ret2; 1410 1411 mlog_errno(ret); 1412 /* 1413 * If set value outside failed, we have to clean 1414 * the junk tree root we have already set in local. 1415 */ 1416 ret2 = ocfs2_xattr_cleanup(inode, xi, xs, offs); 1417 if (ret2 < 0) 1418 mlog_errno(ret2); 1419 } 1420 } 1421 out: 1422 return ret; 1423 1424 } 1425 1426 static int ocfs2_remove_value_outside(struct inode*inode, 1427 struct buffer_head *bh, 1428 struct ocfs2_xattr_header *header) 1429 { 1430 int ret = 0, i; 1431 1432 for (i = 0; i < le16_to_cpu(header->xh_count); i++) { 1433 struct ocfs2_xattr_entry *entry = &header->xh_entries[i]; 1434 1435 if (!ocfs2_xattr_is_local(entry)) { 1436 struct ocfs2_xattr_value_root *xv; 1437 void *val; 1438 1439 val = (void *)header + 1440 le16_to_cpu(entry->xe_name_offset); 1441 xv = (struct ocfs2_xattr_value_root *) 1442 (val + OCFS2_XATTR_SIZE(entry->xe_name_len)); 1443 ret = ocfs2_xattr_value_truncate(inode, bh, xv, 0); 1444 if (ret < 0) { 1445 mlog_errno(ret); 1446 return ret; 1447 } 1448 } 1449 } 1450 1451 return ret; 1452 } 1453 1454 static int ocfs2_xattr_ibody_remove(struct inode *inode, 1455 struct buffer_head *di_bh) 1456 { 1457 1458 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 1459 struct ocfs2_xattr_header *header; 1460 int ret; 1461 1462 header = (struct ocfs2_xattr_header *) 1463 ((void *)di + inode->i_sb->s_blocksize - 1464 le16_to_cpu(di->i_xattr_inline_size)); 1465 1466 ret = ocfs2_remove_value_outside(inode, di_bh, header); 1467 1468 return ret; 1469 } 1470 1471 static int ocfs2_xattr_block_remove(struct inode *inode, 1472 struct buffer_head *blk_bh) 1473 { 1474 struct ocfs2_xattr_block *xb; 1475 int ret = 0; 1476 1477 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 1478 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 1479 struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header); 1480 ret = ocfs2_remove_value_outside(inode, blk_bh, header); 1481 } else 1482 ret = ocfs2_delete_xattr_index_block(inode, blk_bh); 1483 1484 return ret; 1485 } 1486 1487 static int ocfs2_xattr_free_block(struct inode *inode, 1488 u64 block) 1489 { 1490 struct inode *xb_alloc_inode; 1491 struct buffer_head *xb_alloc_bh = NULL; 1492 struct buffer_head *blk_bh = NULL; 1493 struct ocfs2_xattr_block *xb; 1494 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1495 handle_t *handle; 1496 int ret = 0; 1497 u64 blk, bg_blkno; 1498 u16 bit; 1499 1500 ret = ocfs2_read_block(inode, block, &blk_bh); 1501 if (ret < 0) { 1502 mlog_errno(ret); 1503 goto out; 1504 } 1505 1506 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 1507 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) { 1508 ret = -EIO; 1509 goto out; 1510 } 1511 1512 ret = ocfs2_xattr_block_remove(inode, blk_bh); 1513 if (ret < 0) { 1514 mlog_errno(ret); 1515 goto out; 1516 } 1517 1518 blk = le64_to_cpu(xb->xb_blkno); 1519 bit = le16_to_cpu(xb->xb_suballoc_bit); 1520 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 1521 1522 xb_alloc_inode = ocfs2_get_system_file_inode(osb, 1523 EXTENT_ALLOC_SYSTEM_INODE, 1524 le16_to_cpu(xb->xb_suballoc_slot)); 1525 if (!xb_alloc_inode) { 1526 ret = -ENOMEM; 1527 mlog_errno(ret); 1528 goto out; 1529 } 1530 mutex_lock(&xb_alloc_inode->i_mutex); 1531 1532 ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1); 1533 if (ret < 0) { 1534 mlog_errno(ret); 1535 goto out_mutex; 1536 } 1537 1538 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE); 1539 if (IS_ERR(handle)) { 1540 ret = PTR_ERR(handle); 1541 mlog_errno(ret); 1542 goto out_unlock; 1543 } 1544 1545 ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh, 1546 bit, bg_blkno, 1); 1547 if (ret < 0) 1548 mlog_errno(ret); 1549 1550 ocfs2_commit_trans(osb, handle); 1551 out_unlock: 1552 ocfs2_inode_unlock(xb_alloc_inode, 1); 1553 brelse(xb_alloc_bh); 1554 out_mutex: 1555 mutex_unlock(&xb_alloc_inode->i_mutex); 1556 iput(xb_alloc_inode); 1557 out: 1558 brelse(blk_bh); 1559 return ret; 1560 } 1561 1562 /* 1563 * ocfs2_xattr_remove() 1564 * 1565 * Free extended attribute resources associated with this inode. 1566 */ 1567 int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh) 1568 { 1569 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1570 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 1571 handle_t *handle; 1572 int ret; 1573 1574 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 1575 return 0; 1576 1577 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 1578 return 0; 1579 1580 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 1581 ret = ocfs2_xattr_ibody_remove(inode, di_bh); 1582 if (ret < 0) { 1583 mlog_errno(ret); 1584 goto out; 1585 } 1586 } 1587 1588 if (di->i_xattr_loc) { 1589 ret = ocfs2_xattr_free_block(inode, 1590 le64_to_cpu(di->i_xattr_loc)); 1591 if (ret < 0) { 1592 mlog_errno(ret); 1593 goto out; 1594 } 1595 } 1596 1597 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1598 OCFS2_INODE_UPDATE_CREDITS); 1599 if (IS_ERR(handle)) { 1600 ret = PTR_ERR(handle); 1601 mlog_errno(ret); 1602 goto out; 1603 } 1604 ret = ocfs2_journal_access(handle, inode, di_bh, 1605 OCFS2_JOURNAL_ACCESS_WRITE); 1606 if (ret) { 1607 mlog_errno(ret); 1608 goto out_commit; 1609 } 1610 1611 di->i_xattr_loc = 0; 1612 1613 spin_lock(&oi->ip_lock); 1614 oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL); 1615 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 1616 spin_unlock(&oi->ip_lock); 1617 1618 ret = ocfs2_journal_dirty(handle, di_bh); 1619 if (ret < 0) 1620 mlog_errno(ret); 1621 out_commit: 1622 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 1623 out: 1624 return ret; 1625 } 1626 1627 static int ocfs2_xattr_has_space_inline(struct inode *inode, 1628 struct ocfs2_dinode *di) 1629 { 1630 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1631 unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size; 1632 int free; 1633 1634 if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE) 1635 return 0; 1636 1637 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1638 struct ocfs2_inline_data *idata = &di->id2.i_data; 1639 free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size); 1640 } else if (ocfs2_inode_is_fast_symlink(inode)) { 1641 free = ocfs2_fast_symlink_chars(inode->i_sb) - 1642 le64_to_cpu(di->i_size); 1643 } else { 1644 struct ocfs2_extent_list *el = &di->id2.i_list; 1645 free = (le16_to_cpu(el->l_count) - 1646 le16_to_cpu(el->l_next_free_rec)) * 1647 sizeof(struct ocfs2_extent_rec); 1648 } 1649 if (free >= xattrsize) 1650 return 1; 1651 1652 return 0; 1653 } 1654 1655 /* 1656 * ocfs2_xattr_ibody_find() 1657 * 1658 * Find extended attribute in inode block and 1659 * fill search info into struct ocfs2_xattr_search. 1660 */ 1661 static int ocfs2_xattr_ibody_find(struct inode *inode, 1662 int name_index, 1663 const char *name, 1664 struct ocfs2_xattr_search *xs) 1665 { 1666 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1667 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1668 int ret; 1669 int has_space = 0; 1670 1671 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) 1672 return 0; 1673 1674 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) { 1675 down_read(&oi->ip_alloc_sem); 1676 has_space = ocfs2_xattr_has_space_inline(inode, di); 1677 up_read(&oi->ip_alloc_sem); 1678 if (!has_space) 1679 return 0; 1680 } 1681 1682 xs->xattr_bh = xs->inode_bh; 1683 xs->end = (void *)di + inode->i_sb->s_blocksize; 1684 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) 1685 xs->header = (struct ocfs2_xattr_header *) 1686 (xs->end - le16_to_cpu(di->i_xattr_inline_size)); 1687 else 1688 xs->header = (struct ocfs2_xattr_header *) 1689 (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size); 1690 xs->base = (void *)xs->header; 1691 xs->here = xs->header->xh_entries; 1692 1693 /* Find the named attribute. */ 1694 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 1695 ret = ocfs2_xattr_find_entry(name_index, name, xs); 1696 if (ret && ret != -ENODATA) 1697 return ret; 1698 xs->not_found = ret; 1699 } 1700 1701 return 0; 1702 } 1703 1704 /* 1705 * ocfs2_xattr_ibody_set() 1706 * 1707 * Set, replace or remove an extended attribute into inode block. 1708 * 1709 */ 1710 static int ocfs2_xattr_ibody_set(struct inode *inode, 1711 struct ocfs2_xattr_info *xi, 1712 struct ocfs2_xattr_search *xs) 1713 { 1714 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1715 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1716 int ret; 1717 1718 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) 1719 return -ENOSPC; 1720 1721 down_write(&oi->ip_alloc_sem); 1722 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) { 1723 if (!ocfs2_xattr_has_space_inline(inode, di)) { 1724 ret = -ENOSPC; 1725 goto out; 1726 } 1727 } 1728 1729 ret = ocfs2_xattr_set_entry(inode, xi, xs, 1730 (OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL)); 1731 out: 1732 up_write(&oi->ip_alloc_sem); 1733 1734 return ret; 1735 } 1736 1737 /* 1738 * ocfs2_xattr_block_find() 1739 * 1740 * Find extended attribute in external block and 1741 * fill search info into struct ocfs2_xattr_search. 1742 */ 1743 static int ocfs2_xattr_block_find(struct inode *inode, 1744 int name_index, 1745 const char *name, 1746 struct ocfs2_xattr_search *xs) 1747 { 1748 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1749 struct buffer_head *blk_bh = NULL; 1750 struct ocfs2_xattr_block *xb; 1751 int ret = 0; 1752 1753 if (!di->i_xattr_loc) 1754 return ret; 1755 1756 ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh); 1757 if (ret < 0) { 1758 mlog_errno(ret); 1759 return ret; 1760 } 1761 1762 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 1763 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) { 1764 ret = -EIO; 1765 goto cleanup; 1766 } 1767 1768 xs->xattr_bh = blk_bh; 1769 1770 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 1771 xs->header = &xb->xb_attrs.xb_header; 1772 xs->base = (void *)xs->header; 1773 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size; 1774 xs->here = xs->header->xh_entries; 1775 1776 ret = ocfs2_xattr_find_entry(name_index, name, xs); 1777 } else 1778 ret = ocfs2_xattr_index_block_find(inode, blk_bh, 1779 name_index, 1780 name, xs); 1781 1782 if (ret && ret != -ENODATA) { 1783 xs->xattr_bh = NULL; 1784 goto cleanup; 1785 } 1786 xs->not_found = ret; 1787 return 0; 1788 cleanup: 1789 brelse(blk_bh); 1790 1791 return ret; 1792 } 1793 1794 /* 1795 * ocfs2_xattr_block_set() 1796 * 1797 * Set, replace or remove an extended attribute into external block. 1798 * 1799 */ 1800 static int ocfs2_xattr_block_set(struct inode *inode, 1801 struct ocfs2_xattr_info *xi, 1802 struct ocfs2_xattr_search *xs) 1803 { 1804 struct buffer_head *new_bh = NULL; 1805 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1806 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1807 struct ocfs2_alloc_context *meta_ac = NULL; 1808 handle_t *handle = NULL; 1809 struct ocfs2_xattr_block *xblk = NULL; 1810 u16 suballoc_bit_start; 1811 u32 num_got; 1812 u64 first_blkno; 1813 int ret; 1814 1815 if (!xs->xattr_bh) { 1816 /* 1817 * Alloc one external block for extended attribute 1818 * outside of inode. 1819 */ 1820 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac); 1821 if (ret < 0) { 1822 mlog_errno(ret); 1823 goto out; 1824 } 1825 handle = ocfs2_start_trans(osb, 1826 OCFS2_XATTR_BLOCK_CREATE_CREDITS); 1827 if (IS_ERR(handle)) { 1828 ret = PTR_ERR(handle); 1829 mlog_errno(ret); 1830 goto out; 1831 } 1832 ret = ocfs2_journal_access(handle, inode, xs->inode_bh, 1833 OCFS2_JOURNAL_ACCESS_CREATE); 1834 if (ret < 0) { 1835 mlog_errno(ret); 1836 goto out_commit; 1837 } 1838 1839 ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1, 1840 &suballoc_bit_start, &num_got, 1841 &first_blkno); 1842 if (ret < 0) { 1843 mlog_errno(ret); 1844 goto out_commit; 1845 } 1846 1847 new_bh = sb_getblk(inode->i_sb, first_blkno); 1848 ocfs2_set_new_buffer_uptodate(inode, new_bh); 1849 1850 ret = ocfs2_journal_access(handle, inode, new_bh, 1851 OCFS2_JOURNAL_ACCESS_CREATE); 1852 if (ret < 0) { 1853 mlog_errno(ret); 1854 goto out_commit; 1855 } 1856 1857 /* Initialize ocfs2_xattr_block */ 1858 xs->xattr_bh = new_bh; 1859 xblk = (struct ocfs2_xattr_block *)new_bh->b_data; 1860 memset(xblk, 0, inode->i_sb->s_blocksize); 1861 strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE); 1862 xblk->xb_suballoc_slot = cpu_to_le16(osb->slot_num); 1863 xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start); 1864 xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation); 1865 xblk->xb_blkno = cpu_to_le64(first_blkno); 1866 1867 xs->header = &xblk->xb_attrs.xb_header; 1868 xs->base = (void *)xs->header; 1869 xs->end = (void *)xblk + inode->i_sb->s_blocksize; 1870 xs->here = xs->header->xh_entries; 1871 1872 1873 ret = ocfs2_journal_dirty(handle, new_bh); 1874 if (ret < 0) { 1875 mlog_errno(ret); 1876 goto out_commit; 1877 } 1878 di->i_xattr_loc = cpu_to_le64(first_blkno); 1879 ret = ocfs2_journal_dirty(handle, xs->inode_bh); 1880 if (ret < 0) 1881 mlog_errno(ret); 1882 out_commit: 1883 ocfs2_commit_trans(osb, handle); 1884 out: 1885 if (meta_ac) 1886 ocfs2_free_alloc_context(meta_ac); 1887 if (ret < 0) 1888 return ret; 1889 } else 1890 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data; 1891 1892 if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) { 1893 /* Set extended attribute into external block */ 1894 ret = ocfs2_xattr_set_entry(inode, xi, xs, OCFS2_HAS_XATTR_FL); 1895 if (!ret || ret != -ENOSPC) 1896 goto end; 1897 1898 ret = ocfs2_xattr_create_index_block(inode, xs); 1899 if (ret) 1900 goto end; 1901 } 1902 1903 ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs); 1904 1905 end: 1906 1907 return ret; 1908 } 1909 1910 /* 1911 * ocfs2_xattr_set() 1912 * 1913 * Set, replace or remove an extended attribute for this inode. 1914 * value is NULL to remove an existing extended attribute, else either 1915 * create or replace an extended attribute. 1916 */ 1917 int ocfs2_xattr_set(struct inode *inode, 1918 int name_index, 1919 const char *name, 1920 const void *value, 1921 size_t value_len, 1922 int flags) 1923 { 1924 struct buffer_head *di_bh = NULL; 1925 struct ocfs2_dinode *di; 1926 int ret; 1927 u16 i, blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 1928 1929 struct ocfs2_xattr_info xi = { 1930 .name_index = name_index, 1931 .name = name, 1932 .value = value, 1933 .value_len = value_len, 1934 }; 1935 1936 struct ocfs2_xattr_search xis = { 1937 .not_found = -ENODATA, 1938 }; 1939 1940 struct ocfs2_xattr_search xbs = { 1941 .not_found = -ENODATA, 1942 }; 1943 1944 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 1945 return -EOPNOTSUPP; 1946 1947 ret = ocfs2_inode_lock(inode, &di_bh, 1); 1948 if (ret < 0) { 1949 mlog_errno(ret); 1950 return ret; 1951 } 1952 xis.inode_bh = xbs.inode_bh = di_bh; 1953 di = (struct ocfs2_dinode *)di_bh->b_data; 1954 1955 down_write(&OCFS2_I(inode)->ip_xattr_sem); 1956 /* 1957 * Scan inode and external block to find the same name 1958 * extended attribute and collect search infomation. 1959 */ 1960 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis); 1961 if (ret) 1962 goto cleanup; 1963 if (xis.not_found) { 1964 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs); 1965 if (ret) 1966 goto cleanup; 1967 } 1968 1969 if (xis.not_found && xbs.not_found) { 1970 ret = -ENODATA; 1971 if (flags & XATTR_REPLACE) 1972 goto cleanup; 1973 ret = 0; 1974 if (!value) 1975 goto cleanup; 1976 } else { 1977 ret = -EEXIST; 1978 if (flags & XATTR_CREATE) 1979 goto cleanup; 1980 } 1981 1982 if (!value) { 1983 /* Remove existing extended attribute */ 1984 if (!xis.not_found) 1985 ret = ocfs2_xattr_ibody_set(inode, &xi, &xis); 1986 else if (!xbs.not_found) 1987 ret = ocfs2_xattr_block_set(inode, &xi, &xbs); 1988 } else { 1989 /* We always try to set extended attribute into inode first*/ 1990 ret = ocfs2_xattr_ibody_set(inode, &xi, &xis); 1991 if (!ret && !xbs.not_found) { 1992 /* 1993 * If succeed and that extended attribute existing in 1994 * external block, then we will remove it. 1995 */ 1996 xi.value = NULL; 1997 xi.value_len = 0; 1998 ret = ocfs2_xattr_block_set(inode, &xi, &xbs); 1999 } else if (ret == -ENOSPC) { 2000 if (di->i_xattr_loc && !xbs.xattr_bh) { 2001 ret = ocfs2_xattr_block_find(inode, name_index, 2002 name, &xbs); 2003 if (ret) 2004 goto cleanup; 2005 } 2006 /* 2007 * If no space in inode, we will set extended attribute 2008 * into external block. 2009 */ 2010 ret = ocfs2_xattr_block_set(inode, &xi, &xbs); 2011 if (ret) 2012 goto cleanup; 2013 if (!xis.not_found) { 2014 /* 2015 * If succeed and that extended attribute 2016 * existing in inode, we will remove it. 2017 */ 2018 xi.value = NULL; 2019 xi.value_len = 0; 2020 ret = ocfs2_xattr_ibody_set(inode, &xi, &xis); 2021 } 2022 } 2023 } 2024 cleanup: 2025 up_write(&OCFS2_I(inode)->ip_xattr_sem); 2026 ocfs2_inode_unlock(inode, 1); 2027 brelse(di_bh); 2028 brelse(xbs.xattr_bh); 2029 for (i = 0; i < blk_per_bucket; i++) 2030 brelse(xbs.bucket.bhs[i]); 2031 2032 return ret; 2033 } 2034 2035 /* 2036 * Find the xattr extent rec which may contains name_hash. 2037 * e_cpos will be the first name hash of the xattr rec. 2038 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list. 2039 */ 2040 static int ocfs2_xattr_get_rec(struct inode *inode, 2041 u32 name_hash, 2042 u64 *p_blkno, 2043 u32 *e_cpos, 2044 u32 *num_clusters, 2045 struct ocfs2_extent_list *el) 2046 { 2047 int ret = 0, i; 2048 struct buffer_head *eb_bh = NULL; 2049 struct ocfs2_extent_block *eb; 2050 struct ocfs2_extent_rec *rec = NULL; 2051 u64 e_blkno = 0; 2052 2053 if (el->l_tree_depth) { 2054 ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh); 2055 if (ret) { 2056 mlog_errno(ret); 2057 goto out; 2058 } 2059 2060 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 2061 el = &eb->h_list; 2062 2063 if (el->l_tree_depth) { 2064 ocfs2_error(inode->i_sb, 2065 "Inode %lu has non zero tree depth in " 2066 "xattr tree block %llu\n", inode->i_ino, 2067 (unsigned long long)eb_bh->b_blocknr); 2068 ret = -EROFS; 2069 goto out; 2070 } 2071 } 2072 2073 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) { 2074 rec = &el->l_recs[i]; 2075 2076 if (le32_to_cpu(rec->e_cpos) <= name_hash) { 2077 e_blkno = le64_to_cpu(rec->e_blkno); 2078 break; 2079 } 2080 } 2081 2082 if (!e_blkno) { 2083 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " 2084 "record (%u, %u, 0) in xattr", inode->i_ino, 2085 le32_to_cpu(rec->e_cpos), 2086 ocfs2_rec_clusters(el, rec)); 2087 ret = -EROFS; 2088 goto out; 2089 } 2090 2091 *p_blkno = le64_to_cpu(rec->e_blkno); 2092 *num_clusters = le16_to_cpu(rec->e_leaf_clusters); 2093 if (e_cpos) 2094 *e_cpos = le32_to_cpu(rec->e_cpos); 2095 out: 2096 brelse(eb_bh); 2097 return ret; 2098 } 2099 2100 typedef int (xattr_bucket_func)(struct inode *inode, 2101 struct ocfs2_xattr_bucket *bucket, 2102 void *para); 2103 2104 static int ocfs2_find_xe_in_bucket(struct inode *inode, 2105 struct buffer_head *header_bh, 2106 int name_index, 2107 const char *name, 2108 u32 name_hash, 2109 u16 *xe_index, 2110 int *found) 2111 { 2112 int i, ret = 0, cmp = 1, block_off, new_offset; 2113 struct ocfs2_xattr_header *xh = 2114 (struct ocfs2_xattr_header *)header_bh->b_data; 2115 size_t name_len = strlen(name); 2116 struct ocfs2_xattr_entry *xe = NULL; 2117 struct buffer_head *name_bh = NULL; 2118 char *xe_name; 2119 2120 /* 2121 * We don't use binary search in the bucket because there 2122 * may be multiple entries with the same name hash. 2123 */ 2124 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 2125 xe = &xh->xh_entries[i]; 2126 2127 if (name_hash > le32_to_cpu(xe->xe_name_hash)) 2128 continue; 2129 else if (name_hash < le32_to_cpu(xe->xe_name_hash)) 2130 break; 2131 2132 cmp = name_index - ocfs2_xattr_get_type(xe); 2133 if (!cmp) 2134 cmp = name_len - xe->xe_name_len; 2135 if (cmp) 2136 continue; 2137 2138 ret = ocfs2_xattr_bucket_get_name_value(inode, 2139 xh, 2140 i, 2141 &block_off, 2142 &new_offset); 2143 if (ret) { 2144 mlog_errno(ret); 2145 break; 2146 } 2147 2148 ret = ocfs2_read_block(inode, header_bh->b_blocknr + block_off, 2149 &name_bh); 2150 if (ret) { 2151 mlog_errno(ret); 2152 break; 2153 } 2154 xe_name = name_bh->b_data + new_offset; 2155 2156 cmp = memcmp(name, xe_name, name_len); 2157 brelse(name_bh); 2158 name_bh = NULL; 2159 2160 if (cmp == 0) { 2161 *xe_index = i; 2162 *found = 1; 2163 ret = 0; 2164 break; 2165 } 2166 } 2167 2168 return ret; 2169 } 2170 2171 /* 2172 * Find the specified xattr entry in a series of buckets. 2173 * This series start from p_blkno and last for num_clusters. 2174 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains 2175 * the num of the valid buckets. 2176 * 2177 * Return the buffer_head this xattr should reside in. And if the xattr's 2178 * hash is in the gap of 2 buckets, return the lower bucket. 2179 */ 2180 static int ocfs2_xattr_bucket_find(struct inode *inode, 2181 int name_index, 2182 const char *name, 2183 u32 name_hash, 2184 u64 p_blkno, 2185 u32 first_hash, 2186 u32 num_clusters, 2187 struct ocfs2_xattr_search *xs) 2188 { 2189 int ret, found = 0; 2190 struct buffer_head *bh = NULL; 2191 struct buffer_head *lower_bh = NULL; 2192 struct ocfs2_xattr_header *xh = NULL; 2193 struct ocfs2_xattr_entry *xe = NULL; 2194 u16 index = 0; 2195 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 2196 int low_bucket = 0, bucket, high_bucket; 2197 u32 last_hash; 2198 u64 blkno; 2199 2200 ret = ocfs2_read_block(inode, p_blkno, &bh); 2201 if (ret) { 2202 mlog_errno(ret); 2203 goto out; 2204 } 2205 2206 xh = (struct ocfs2_xattr_header *)bh->b_data; 2207 high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1; 2208 2209 while (low_bucket <= high_bucket) { 2210 brelse(bh); 2211 bh = NULL; 2212 bucket = (low_bucket + high_bucket) / 2; 2213 2214 blkno = p_blkno + bucket * blk_per_bucket; 2215 2216 ret = ocfs2_read_block(inode, blkno, &bh); 2217 if (ret) { 2218 mlog_errno(ret); 2219 goto out; 2220 } 2221 2222 xh = (struct ocfs2_xattr_header *)bh->b_data; 2223 xe = &xh->xh_entries[0]; 2224 if (name_hash < le32_to_cpu(xe->xe_name_hash)) { 2225 high_bucket = bucket - 1; 2226 continue; 2227 } 2228 2229 /* 2230 * Check whether the hash of the last entry in our 2231 * bucket is larger than the search one. for an empty 2232 * bucket, the last one is also the first one. 2233 */ 2234 if (xh->xh_count) 2235 xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1]; 2236 2237 last_hash = le32_to_cpu(xe->xe_name_hash); 2238 2239 /* record lower_bh which may be the insert place. */ 2240 brelse(lower_bh); 2241 lower_bh = bh; 2242 bh = NULL; 2243 2244 if (name_hash > le32_to_cpu(xe->xe_name_hash)) { 2245 low_bucket = bucket + 1; 2246 continue; 2247 } 2248 2249 /* the searched xattr should reside in this bucket if exists. */ 2250 ret = ocfs2_find_xe_in_bucket(inode, lower_bh, 2251 name_index, name, name_hash, 2252 &index, &found); 2253 if (ret) { 2254 mlog_errno(ret); 2255 goto out; 2256 } 2257 break; 2258 } 2259 2260 /* 2261 * Record the bucket we have found. 2262 * When the xattr's hash value is in the gap of 2 buckets, we will 2263 * always set it to the previous bucket. 2264 */ 2265 if (!lower_bh) { 2266 /* 2267 * We can't find any bucket whose first name_hash is less 2268 * than the find name_hash. 2269 */ 2270 BUG_ON(bh->b_blocknr != p_blkno); 2271 lower_bh = bh; 2272 bh = NULL; 2273 } 2274 xs->bucket.bhs[0] = lower_bh; 2275 xs->bucket.xh = (struct ocfs2_xattr_header *) 2276 xs->bucket.bhs[0]->b_data; 2277 lower_bh = NULL; 2278 2279 xs->header = xs->bucket.xh; 2280 xs->base = xs->bucket.bhs[0]->b_data; 2281 xs->end = xs->base + inode->i_sb->s_blocksize; 2282 2283 if (found) { 2284 /* 2285 * If we have found the xattr enty, read all the blocks in 2286 * this bucket. 2287 */ 2288 ret = ocfs2_read_blocks(inode, xs->bucket.bhs[0]->b_blocknr + 1, 2289 blk_per_bucket - 1, &xs->bucket.bhs[1], 2290 0); 2291 if (ret) { 2292 mlog_errno(ret); 2293 goto out; 2294 } 2295 2296 xs->here = &xs->header->xh_entries[index]; 2297 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name, 2298 (unsigned long long)xs->bucket.bhs[0]->b_blocknr, index); 2299 } else 2300 ret = -ENODATA; 2301 2302 out: 2303 brelse(bh); 2304 brelse(lower_bh); 2305 return ret; 2306 } 2307 2308 static int ocfs2_xattr_index_block_find(struct inode *inode, 2309 struct buffer_head *root_bh, 2310 int name_index, 2311 const char *name, 2312 struct ocfs2_xattr_search *xs) 2313 { 2314 int ret; 2315 struct ocfs2_xattr_block *xb = 2316 (struct ocfs2_xattr_block *)root_bh->b_data; 2317 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root; 2318 struct ocfs2_extent_list *el = &xb_root->xt_list; 2319 u64 p_blkno = 0; 2320 u32 first_hash, num_clusters = 0; 2321 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name)); 2322 2323 if (le16_to_cpu(el->l_next_free_rec) == 0) 2324 return -ENODATA; 2325 2326 mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n", 2327 name, name_hash, name_index); 2328 2329 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash, 2330 &num_clusters, el); 2331 if (ret) { 2332 mlog_errno(ret); 2333 goto out; 2334 } 2335 2336 BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash); 2337 2338 mlog(0, "find xattr extent rec %u clusters from %llu, the first hash " 2339 "in the rec is %u\n", num_clusters, p_blkno, first_hash); 2340 2341 ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash, 2342 p_blkno, first_hash, num_clusters, xs); 2343 2344 out: 2345 return ret; 2346 } 2347 2348 static int ocfs2_iterate_xattr_buckets(struct inode *inode, 2349 u64 blkno, 2350 u32 clusters, 2351 xattr_bucket_func *func, 2352 void *para) 2353 { 2354 int i, j, ret = 0; 2355 int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 2356 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)); 2357 u32 num_buckets = clusters * bpc; 2358 struct ocfs2_xattr_bucket bucket; 2359 2360 memset(&bucket, 0, sizeof(bucket)); 2361 2362 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n", 2363 clusters, blkno); 2364 2365 for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) { 2366 ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket, 2367 bucket.bhs, 0); 2368 if (ret) { 2369 mlog_errno(ret); 2370 goto out; 2371 } 2372 2373 bucket.xh = (struct ocfs2_xattr_header *)bucket.bhs[0]->b_data; 2374 /* 2375 * The real bucket num in this series of blocks is stored 2376 * in the 1st bucket. 2377 */ 2378 if (i == 0) 2379 num_buckets = le16_to_cpu(bucket.xh->xh_num_buckets); 2380 2381 mlog(0, "iterating xattr bucket %llu, first hash %u\n", blkno, 2382 le32_to_cpu(bucket.xh->xh_entries[0].xe_name_hash)); 2383 if (func) { 2384 ret = func(inode, &bucket, para); 2385 if (ret) { 2386 mlog_errno(ret); 2387 break; 2388 } 2389 } 2390 2391 for (j = 0; j < blk_per_bucket; j++) 2392 brelse(bucket.bhs[j]); 2393 memset(&bucket, 0, sizeof(bucket)); 2394 } 2395 2396 out: 2397 for (j = 0; j < blk_per_bucket; j++) 2398 brelse(bucket.bhs[j]); 2399 2400 return ret; 2401 } 2402 2403 struct ocfs2_xattr_tree_list { 2404 char *buffer; 2405 size_t buffer_size; 2406 size_t result; 2407 }; 2408 2409 static int ocfs2_xattr_bucket_get_name_value(struct inode *inode, 2410 struct ocfs2_xattr_header *xh, 2411 int index, 2412 int *block_off, 2413 int *new_offset) 2414 { 2415 u16 name_offset; 2416 2417 if (index < 0 || index >= le16_to_cpu(xh->xh_count)) 2418 return -EINVAL; 2419 2420 name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset); 2421 2422 *block_off = name_offset >> inode->i_sb->s_blocksize_bits; 2423 *new_offset = name_offset % inode->i_sb->s_blocksize; 2424 2425 return 0; 2426 } 2427 2428 static int ocfs2_list_xattr_bucket(struct inode *inode, 2429 struct ocfs2_xattr_bucket *bucket, 2430 void *para) 2431 { 2432 int ret = 0, type; 2433 struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para; 2434 int i, block_off, new_offset; 2435 const char *prefix, *name; 2436 2437 for (i = 0 ; i < le16_to_cpu(bucket->xh->xh_count); i++) { 2438 struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i]; 2439 type = ocfs2_xattr_get_type(entry); 2440 prefix = ocfs2_xattr_prefix(type); 2441 2442 if (prefix) { 2443 ret = ocfs2_xattr_bucket_get_name_value(inode, 2444 bucket->xh, 2445 i, 2446 &block_off, 2447 &new_offset); 2448 if (ret) 2449 break; 2450 2451 name = (const char *)bucket->bhs[block_off]->b_data + 2452 new_offset; 2453 ret = ocfs2_xattr_list_entry(xl->buffer, 2454 xl->buffer_size, 2455 &xl->result, 2456 prefix, name, 2457 entry->xe_name_len); 2458 if (ret) 2459 break; 2460 } 2461 } 2462 2463 return ret; 2464 } 2465 2466 static int ocfs2_xattr_tree_list_index_block(struct inode *inode, 2467 struct ocfs2_xattr_tree_root *xt, 2468 char *buffer, 2469 size_t buffer_size) 2470 { 2471 struct ocfs2_extent_list *el = &xt->xt_list; 2472 int ret = 0; 2473 u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0; 2474 u64 p_blkno = 0; 2475 struct ocfs2_xattr_tree_list xl = { 2476 .buffer = buffer, 2477 .buffer_size = buffer_size, 2478 .result = 0, 2479 }; 2480 2481 if (le16_to_cpu(el->l_next_free_rec) == 0) 2482 return 0; 2483 2484 while (name_hash > 0) { 2485 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, 2486 &e_cpos, &num_clusters, el); 2487 if (ret) { 2488 mlog_errno(ret); 2489 goto out; 2490 } 2491 2492 ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters, 2493 ocfs2_list_xattr_bucket, 2494 &xl); 2495 if (ret) { 2496 mlog_errno(ret); 2497 goto out; 2498 } 2499 2500 if (e_cpos == 0) 2501 break; 2502 2503 name_hash = e_cpos - 1; 2504 } 2505 2506 ret = xl.result; 2507 out: 2508 return ret; 2509 } 2510 2511 static int cmp_xe(const void *a, const void *b) 2512 { 2513 const struct ocfs2_xattr_entry *l = a, *r = b; 2514 u32 l_hash = le32_to_cpu(l->xe_name_hash); 2515 u32 r_hash = le32_to_cpu(r->xe_name_hash); 2516 2517 if (l_hash > r_hash) 2518 return 1; 2519 if (l_hash < r_hash) 2520 return -1; 2521 return 0; 2522 } 2523 2524 static void swap_xe(void *a, void *b, int size) 2525 { 2526 struct ocfs2_xattr_entry *l = a, *r = b, tmp; 2527 2528 tmp = *l; 2529 memcpy(l, r, sizeof(struct ocfs2_xattr_entry)); 2530 memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry)); 2531 } 2532 2533 /* 2534 * When the ocfs2_xattr_block is filled up, new bucket will be created 2535 * and all the xattr entries will be moved to the new bucket. 2536 * Note: we need to sort the entries since they are not saved in order 2537 * in the ocfs2_xattr_block. 2538 */ 2539 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode, 2540 struct buffer_head *xb_bh, 2541 struct buffer_head *xh_bh, 2542 struct buffer_head *data_bh) 2543 { 2544 int i, blocksize = inode->i_sb->s_blocksize; 2545 u16 offset, size, off_change; 2546 struct ocfs2_xattr_entry *xe; 2547 struct ocfs2_xattr_block *xb = 2548 (struct ocfs2_xattr_block *)xb_bh->b_data; 2549 struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header; 2550 struct ocfs2_xattr_header *xh = 2551 (struct ocfs2_xattr_header *)xh_bh->b_data; 2552 u16 count = le16_to_cpu(xb_xh->xh_count); 2553 char *target = xh_bh->b_data, *src = xb_bh->b_data; 2554 2555 mlog(0, "cp xattr from block %llu to bucket %llu\n", 2556 (unsigned long long)xb_bh->b_blocknr, 2557 (unsigned long long)xh_bh->b_blocknr); 2558 2559 memset(xh_bh->b_data, 0, blocksize); 2560 if (data_bh) 2561 memset(data_bh->b_data, 0, blocksize); 2562 /* 2563 * Since the xe_name_offset is based on ocfs2_xattr_header, 2564 * there is a offset change corresponding to the change of 2565 * ocfs2_xattr_header's position. 2566 */ 2567 off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 2568 xe = &xb_xh->xh_entries[count - 1]; 2569 offset = le16_to_cpu(xe->xe_name_offset) + off_change; 2570 size = blocksize - offset; 2571 2572 /* copy all the names and values. */ 2573 if (data_bh) 2574 target = data_bh->b_data; 2575 memcpy(target + offset, src + offset, size); 2576 2577 /* Init new header now. */ 2578 xh->xh_count = xb_xh->xh_count; 2579 xh->xh_num_buckets = cpu_to_le16(1); 2580 xh->xh_name_value_len = cpu_to_le16(size); 2581 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size); 2582 2583 /* copy all the entries. */ 2584 target = xh_bh->b_data; 2585 offset = offsetof(struct ocfs2_xattr_header, xh_entries); 2586 size = count * sizeof(struct ocfs2_xattr_entry); 2587 memcpy(target + offset, (char *)xb_xh + offset, size); 2588 2589 /* Change the xe offset for all the xe because of the move. */ 2590 off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize + 2591 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 2592 for (i = 0; i < count; i++) 2593 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change); 2594 2595 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n", 2596 offset, size, off_change); 2597 2598 sort(target + offset, count, sizeof(struct ocfs2_xattr_entry), 2599 cmp_xe, swap_xe); 2600 } 2601 2602 /* 2603 * After we move xattr from block to index btree, we have to 2604 * update ocfs2_xattr_search to the new xe and base. 2605 * 2606 * When the entry is in xattr block, xattr_bh indicates the storage place. 2607 * While if the entry is in index b-tree, "bucket" indicates the 2608 * real place of the xattr. 2609 */ 2610 static int ocfs2_xattr_update_xattr_search(struct inode *inode, 2611 struct ocfs2_xattr_search *xs, 2612 struct buffer_head *old_bh, 2613 struct buffer_head *new_bh) 2614 { 2615 int ret = 0; 2616 char *buf = old_bh->b_data; 2617 struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf; 2618 struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header; 2619 int i, blocksize = inode->i_sb->s_blocksize; 2620 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 2621 2622 xs->bucket.bhs[0] = new_bh; 2623 get_bh(new_bh); 2624 xs->bucket.xh = (struct ocfs2_xattr_header *)xs->bucket.bhs[0]->b_data; 2625 xs->header = xs->bucket.xh; 2626 2627 xs->base = new_bh->b_data; 2628 xs->end = xs->base + inode->i_sb->s_blocksize; 2629 2630 if (!xs->not_found) { 2631 if (OCFS2_XATTR_BUCKET_SIZE != blocksize) { 2632 ret = ocfs2_read_blocks(inode, 2633 xs->bucket.bhs[0]->b_blocknr + 1, 2634 blk_per_bucket - 1, &xs->bucket.bhs[1], 2635 0); 2636 if (ret) { 2637 mlog_errno(ret); 2638 return ret; 2639 } 2640 2641 i = xs->here - old_xh->xh_entries; 2642 xs->here = &xs->header->xh_entries[i]; 2643 } 2644 } 2645 2646 return ret; 2647 } 2648 2649 static int ocfs2_xattr_create_index_block(struct inode *inode, 2650 struct ocfs2_xattr_search *xs) 2651 { 2652 int ret, credits = OCFS2_SUBALLOC_ALLOC; 2653 u32 bit_off, len; 2654 u64 blkno; 2655 handle_t *handle; 2656 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2657 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2658 struct ocfs2_alloc_context *data_ac; 2659 struct buffer_head *xh_bh = NULL, *data_bh = NULL; 2660 struct buffer_head *xb_bh = xs->xattr_bh; 2661 struct ocfs2_xattr_block *xb = 2662 (struct ocfs2_xattr_block *)xb_bh->b_data; 2663 struct ocfs2_xattr_tree_root *xr; 2664 u16 xb_flags = le16_to_cpu(xb->xb_flags); 2665 u16 bpb = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 2666 2667 mlog(0, "create xattr index block for %llu\n", 2668 (unsigned long long)xb_bh->b_blocknr); 2669 2670 BUG_ON(xb_flags & OCFS2_XATTR_INDEXED); 2671 2672 ret = ocfs2_reserve_clusters(osb, 1, &data_ac); 2673 if (ret) { 2674 mlog_errno(ret); 2675 goto out; 2676 } 2677 2678 /* 2679 * XXX: 2680 * We can use this lock for now, and maybe move to a dedicated mutex 2681 * if performance becomes a problem later. 2682 */ 2683 down_write(&oi->ip_alloc_sem); 2684 2685 /* 2686 * 3 more credits, one for xattr block update, one for the 1st block 2687 * of the new xattr bucket and one for the value/data. 2688 */ 2689 credits += 3; 2690 handle = ocfs2_start_trans(osb, credits); 2691 if (IS_ERR(handle)) { 2692 ret = PTR_ERR(handle); 2693 mlog_errno(ret); 2694 goto out_sem; 2695 } 2696 2697 ret = ocfs2_journal_access(handle, inode, xb_bh, 2698 OCFS2_JOURNAL_ACCESS_WRITE); 2699 if (ret) { 2700 mlog_errno(ret); 2701 goto out_commit; 2702 } 2703 2704 ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, &len); 2705 if (ret) { 2706 mlog_errno(ret); 2707 goto out_commit; 2708 } 2709 2710 /* 2711 * The bucket may spread in many blocks, and 2712 * we will only touch the 1st block and the last block 2713 * in the whole bucket(one for entry and one for data). 2714 */ 2715 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); 2716 2717 mlog(0, "allocate 1 cluster from %llu to xattr block\n", blkno); 2718 2719 xh_bh = sb_getblk(inode->i_sb, blkno); 2720 if (!xh_bh) { 2721 ret = -EIO; 2722 mlog_errno(ret); 2723 goto out_commit; 2724 } 2725 2726 ocfs2_set_new_buffer_uptodate(inode, xh_bh); 2727 2728 ret = ocfs2_journal_access(handle, inode, xh_bh, 2729 OCFS2_JOURNAL_ACCESS_CREATE); 2730 if (ret) { 2731 mlog_errno(ret); 2732 goto out_commit; 2733 } 2734 2735 if (bpb > 1) { 2736 data_bh = sb_getblk(inode->i_sb, blkno + bpb - 1); 2737 if (!data_bh) { 2738 ret = -EIO; 2739 mlog_errno(ret); 2740 goto out_commit; 2741 } 2742 2743 ocfs2_set_new_buffer_uptodate(inode, data_bh); 2744 2745 ret = ocfs2_journal_access(handle, inode, data_bh, 2746 OCFS2_JOURNAL_ACCESS_CREATE); 2747 if (ret) { 2748 mlog_errno(ret); 2749 goto out_commit; 2750 } 2751 } 2752 2753 ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xh_bh, data_bh); 2754 2755 ocfs2_journal_dirty(handle, xh_bh); 2756 if (data_bh) 2757 ocfs2_journal_dirty(handle, data_bh); 2758 2759 ret = ocfs2_xattr_update_xattr_search(inode, xs, xb_bh, xh_bh); 2760 if (ret) { 2761 mlog_errno(ret); 2762 goto out_commit; 2763 } 2764 2765 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */ 2766 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize - 2767 offsetof(struct ocfs2_xattr_block, xb_attrs)); 2768 2769 xr = &xb->xb_attrs.xb_root; 2770 xr->xt_clusters = cpu_to_le32(1); 2771 xr->xt_last_eb_blk = 0; 2772 xr->xt_list.l_tree_depth = 0; 2773 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb)); 2774 xr->xt_list.l_next_free_rec = cpu_to_le16(1); 2775 2776 xr->xt_list.l_recs[0].e_cpos = 0; 2777 xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno); 2778 xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1); 2779 2780 xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED); 2781 2782 ret = ocfs2_journal_dirty(handle, xb_bh); 2783 if (ret) { 2784 mlog_errno(ret); 2785 goto out_commit; 2786 } 2787 2788 out_commit: 2789 ocfs2_commit_trans(osb, handle); 2790 2791 out_sem: 2792 up_write(&oi->ip_alloc_sem); 2793 2794 out: 2795 if (data_ac) 2796 ocfs2_free_alloc_context(data_ac); 2797 2798 brelse(xh_bh); 2799 brelse(data_bh); 2800 2801 return ret; 2802 } 2803 2804 static int cmp_xe_offset(const void *a, const void *b) 2805 { 2806 const struct ocfs2_xattr_entry *l = a, *r = b; 2807 u32 l_name_offset = le16_to_cpu(l->xe_name_offset); 2808 u32 r_name_offset = le16_to_cpu(r->xe_name_offset); 2809 2810 if (l_name_offset < r_name_offset) 2811 return 1; 2812 if (l_name_offset > r_name_offset) 2813 return -1; 2814 return 0; 2815 } 2816 2817 /* 2818 * defrag a xattr bucket if we find that the bucket has some 2819 * holes beteen name/value pairs. 2820 * We will move all the name/value pairs to the end of the bucket 2821 * so that we can spare some space for insertion. 2822 */ 2823 static int ocfs2_defrag_xattr_bucket(struct inode *inode, 2824 struct ocfs2_xattr_bucket *bucket) 2825 { 2826 int ret, i; 2827 size_t end, offset, len, value_len; 2828 struct ocfs2_xattr_header *xh; 2829 char *entries, *buf, *bucket_buf = NULL; 2830 u64 blkno = bucket->bhs[0]->b_blocknr; 2831 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 2832 u16 xh_free_start; 2833 size_t blocksize = inode->i_sb->s_blocksize; 2834 handle_t *handle; 2835 struct buffer_head **bhs; 2836 struct ocfs2_xattr_entry *xe; 2837 2838 bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket, 2839 GFP_NOFS); 2840 if (!bhs) 2841 return -ENOMEM; 2842 2843 ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket, bhs, 0); 2844 if (ret) 2845 goto out; 2846 2847 /* 2848 * In order to make the operation more efficient and generic, 2849 * we copy all the blocks into a contiguous memory and do the 2850 * defragment there, so if anything is error, we will not touch 2851 * the real block. 2852 */ 2853 bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS); 2854 if (!bucket_buf) { 2855 ret = -EIO; 2856 goto out; 2857 } 2858 2859 buf = bucket_buf; 2860 for (i = 0; i < blk_per_bucket; i++, buf += blocksize) 2861 memcpy(buf, bhs[i]->b_data, blocksize); 2862 2863 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), blk_per_bucket); 2864 if (IS_ERR(handle)) { 2865 ret = PTR_ERR(handle); 2866 handle = NULL; 2867 mlog_errno(ret); 2868 goto out; 2869 } 2870 2871 for (i = 0; i < blk_per_bucket; i++) { 2872 ret = ocfs2_journal_access(handle, inode, bhs[i], 2873 OCFS2_JOURNAL_ACCESS_WRITE); 2874 if (ret < 0) { 2875 mlog_errno(ret); 2876 goto commit; 2877 } 2878 } 2879 2880 xh = (struct ocfs2_xattr_header *)bucket_buf; 2881 entries = (char *)xh->xh_entries; 2882 xh_free_start = le16_to_cpu(xh->xh_free_start); 2883 2884 mlog(0, "adjust xattr bucket in %llu, count = %u, " 2885 "xh_free_start = %u, xh_name_value_len = %u.\n", 2886 blkno, le16_to_cpu(xh->xh_count), xh_free_start, 2887 le16_to_cpu(xh->xh_name_value_len)); 2888 2889 /* 2890 * sort all the entries by their offset. 2891 * the largest will be the first, so that we can 2892 * move them to the end one by one. 2893 */ 2894 sort(entries, le16_to_cpu(xh->xh_count), 2895 sizeof(struct ocfs2_xattr_entry), 2896 cmp_xe_offset, swap_xe); 2897 2898 /* Move all name/values to the end of the bucket. */ 2899 xe = xh->xh_entries; 2900 end = OCFS2_XATTR_BUCKET_SIZE; 2901 for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) { 2902 offset = le16_to_cpu(xe->xe_name_offset); 2903 if (ocfs2_xattr_is_local(xe)) 2904 value_len = OCFS2_XATTR_SIZE( 2905 le64_to_cpu(xe->xe_value_size)); 2906 else 2907 value_len = OCFS2_XATTR_ROOT_SIZE; 2908 len = OCFS2_XATTR_SIZE(xe->xe_name_len) + value_len; 2909 2910 /* 2911 * We must make sure that the name/value pair 2912 * exist in the same block. So adjust end to 2913 * the previous block end if needed. 2914 */ 2915 if (((end - len) / blocksize != 2916 (end - 1) / blocksize)) 2917 end = end - end % blocksize; 2918 2919 if (end > offset + len) { 2920 memmove(bucket_buf + end - len, 2921 bucket_buf + offset, len); 2922 xe->xe_name_offset = cpu_to_le16(end - len); 2923 } 2924 2925 mlog_bug_on_msg(end < offset + len, "Defrag check failed for " 2926 "bucket %llu\n", (unsigned long long)blkno); 2927 2928 end -= len; 2929 } 2930 2931 mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for " 2932 "bucket %llu\n", (unsigned long long)blkno); 2933 2934 if (xh_free_start == end) 2935 goto commit; 2936 2937 memset(bucket_buf + xh_free_start, 0, end - xh_free_start); 2938 xh->xh_free_start = cpu_to_le16(end); 2939 2940 /* sort the entries by their name_hash. */ 2941 sort(entries, le16_to_cpu(xh->xh_count), 2942 sizeof(struct ocfs2_xattr_entry), 2943 cmp_xe, swap_xe); 2944 2945 buf = bucket_buf; 2946 for (i = 0; i < blk_per_bucket; i++, buf += blocksize) { 2947 memcpy(bhs[i]->b_data, buf, blocksize); 2948 ocfs2_journal_dirty(handle, bhs[i]); 2949 } 2950 2951 commit: 2952 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 2953 out: 2954 2955 if (bhs) { 2956 for (i = 0; i < blk_per_bucket; i++) 2957 brelse(bhs[i]); 2958 } 2959 kfree(bhs); 2960 2961 kfree(bucket_buf); 2962 return ret; 2963 } 2964 2965 /* 2966 * Move half nums of the xattr bucket in the previous cluster to this new 2967 * cluster. We only touch the last cluster of the previous extend record. 2968 * 2969 * first_bh is the first buffer_head of a series of bucket in the same 2970 * extent rec and header_bh is the header of one bucket in this cluster. 2971 * They will be updated if we move the data header_bh contains to the new 2972 * cluster. first_hash will be set as the 1st xe's name_hash of the new cluster. 2973 */ 2974 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode, 2975 handle_t *handle, 2976 struct buffer_head **first_bh, 2977 struct buffer_head **header_bh, 2978 u64 new_blkno, 2979 u64 prev_blkno, 2980 u32 num_clusters, 2981 u32 *first_hash) 2982 { 2983 int i, ret, credits; 2984 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2985 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 2986 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb); 2987 int blocksize = inode->i_sb->s_blocksize; 2988 struct buffer_head *old_bh, *new_bh, *prev_bh, *new_first_bh = NULL; 2989 struct ocfs2_xattr_header *new_xh; 2990 struct ocfs2_xattr_header *xh = 2991 (struct ocfs2_xattr_header *)((*first_bh)->b_data); 2992 2993 BUG_ON(le16_to_cpu(xh->xh_num_buckets) < num_buckets); 2994 BUG_ON(OCFS2_XATTR_BUCKET_SIZE == osb->s_clustersize); 2995 2996 prev_bh = *first_bh; 2997 get_bh(prev_bh); 2998 xh = (struct ocfs2_xattr_header *)prev_bh->b_data; 2999 3000 prev_blkno += (num_clusters - 1) * bpc + bpc / 2; 3001 3002 mlog(0, "move half of xattrs in cluster %llu to %llu\n", 3003 prev_blkno, new_blkno); 3004 3005 /* 3006 * We need to update the 1st half of the new cluster and 3007 * 1 more for the update of the 1st bucket of the previous 3008 * extent record. 3009 */ 3010 credits = bpc / 2 + 1; 3011 ret = ocfs2_extend_trans(handle, credits); 3012 if (ret) { 3013 mlog_errno(ret); 3014 goto out; 3015 } 3016 3017 ret = ocfs2_journal_access(handle, inode, prev_bh, 3018 OCFS2_JOURNAL_ACCESS_WRITE); 3019 if (ret) { 3020 mlog_errno(ret); 3021 goto out; 3022 } 3023 3024 for (i = 0; i < bpc / 2; i++, prev_blkno++, new_blkno++) { 3025 old_bh = new_bh = NULL; 3026 new_bh = sb_getblk(inode->i_sb, new_blkno); 3027 if (!new_bh) { 3028 ret = -EIO; 3029 mlog_errno(ret); 3030 goto out; 3031 } 3032 3033 ocfs2_set_new_buffer_uptodate(inode, new_bh); 3034 3035 ret = ocfs2_journal_access(handle, inode, new_bh, 3036 OCFS2_JOURNAL_ACCESS_CREATE); 3037 if (ret < 0) { 3038 mlog_errno(ret); 3039 brelse(new_bh); 3040 goto out; 3041 } 3042 3043 ret = ocfs2_read_block(inode, prev_blkno, &old_bh); 3044 if (ret < 0) { 3045 mlog_errno(ret); 3046 brelse(new_bh); 3047 goto out; 3048 } 3049 3050 memcpy(new_bh->b_data, old_bh->b_data, blocksize); 3051 3052 if (i == 0) { 3053 new_xh = (struct ocfs2_xattr_header *)new_bh->b_data; 3054 new_xh->xh_num_buckets = cpu_to_le16(num_buckets / 2); 3055 3056 if (first_hash) 3057 *first_hash = le32_to_cpu( 3058 new_xh->xh_entries[0].xe_name_hash); 3059 new_first_bh = new_bh; 3060 get_bh(new_first_bh); 3061 } 3062 3063 ocfs2_journal_dirty(handle, new_bh); 3064 3065 if (*header_bh == old_bh) { 3066 brelse(*header_bh); 3067 *header_bh = new_bh; 3068 get_bh(*header_bh); 3069 3070 brelse(*first_bh); 3071 *first_bh = new_first_bh; 3072 get_bh(*first_bh); 3073 } 3074 brelse(new_bh); 3075 brelse(old_bh); 3076 } 3077 3078 le16_add_cpu(&xh->xh_num_buckets, -(num_buckets / 2)); 3079 3080 ocfs2_journal_dirty(handle, prev_bh); 3081 out: 3082 brelse(prev_bh); 3083 brelse(new_first_bh); 3084 return ret; 3085 } 3086 3087 static int ocfs2_read_xattr_bucket(struct inode *inode, 3088 u64 blkno, 3089 struct buffer_head **bhs, 3090 int new) 3091 { 3092 int ret = 0; 3093 u16 i, blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3094 3095 if (!new) 3096 return ocfs2_read_blocks(inode, blkno, 3097 blk_per_bucket, bhs, 0); 3098 3099 for (i = 0; i < blk_per_bucket; i++) { 3100 bhs[i] = sb_getblk(inode->i_sb, blkno + i); 3101 if (bhs[i] == NULL) { 3102 ret = -EIO; 3103 mlog_errno(ret); 3104 break; 3105 } 3106 ocfs2_set_new_buffer_uptodate(inode, bhs[i]); 3107 } 3108 3109 return ret; 3110 } 3111 3112 /* 3113 * Move half num of the xattrs in old bucket(blk) to new bucket(new_blk). 3114 * first_hash will record the 1st hash of the new bucket. 3115 */ 3116 static int ocfs2_half_xattr_bucket(struct inode *inode, 3117 handle_t *handle, 3118 u64 blk, 3119 u64 new_blk, 3120 u32 *first_hash, 3121 int new_bucket_head) 3122 { 3123 int ret, i; 3124 u16 count, start, len, name_value_len, xe_len, name_offset; 3125 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3126 struct buffer_head **s_bhs, **t_bhs = NULL; 3127 struct ocfs2_xattr_header *xh; 3128 struct ocfs2_xattr_entry *xe; 3129 int blocksize = inode->i_sb->s_blocksize; 3130 3131 mlog(0, "move half of xattrs from bucket %llu to %llu\n", 3132 blk, new_blk); 3133 3134 s_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS); 3135 if (!s_bhs) 3136 return -ENOMEM; 3137 3138 ret = ocfs2_read_xattr_bucket(inode, blk, s_bhs, 0); 3139 if (ret) { 3140 mlog_errno(ret); 3141 goto out; 3142 } 3143 3144 ret = ocfs2_journal_access(handle, inode, s_bhs[0], 3145 OCFS2_JOURNAL_ACCESS_WRITE); 3146 if (ret) { 3147 mlog_errno(ret); 3148 goto out; 3149 } 3150 3151 t_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS); 3152 if (!t_bhs) { 3153 ret = -ENOMEM; 3154 goto out; 3155 } 3156 3157 ret = ocfs2_read_xattr_bucket(inode, new_blk, t_bhs, new_bucket_head); 3158 if (ret) { 3159 mlog_errno(ret); 3160 goto out; 3161 } 3162 3163 for (i = 0; i < blk_per_bucket; i++) { 3164 ret = ocfs2_journal_access(handle, inode, t_bhs[i], 3165 new_bucket_head ? 3166 OCFS2_JOURNAL_ACCESS_CREATE : 3167 OCFS2_JOURNAL_ACCESS_WRITE); 3168 if (ret) { 3169 mlog_errno(ret); 3170 goto out; 3171 } 3172 } 3173 3174 /* copy the whole bucket to the new first. */ 3175 for (i = 0; i < blk_per_bucket; i++) 3176 memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize); 3177 3178 /* update the new bucket. */ 3179 xh = (struct ocfs2_xattr_header *)t_bhs[0]->b_data; 3180 count = le16_to_cpu(xh->xh_count); 3181 start = count / 2; 3182 3183 /* 3184 * Calculate the total name/value len and xh_free_start for 3185 * the old bucket first. 3186 */ 3187 name_offset = OCFS2_XATTR_BUCKET_SIZE; 3188 name_value_len = 0; 3189 for (i = 0; i < start; i++) { 3190 xe = &xh->xh_entries[i]; 3191 xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3192 if (ocfs2_xattr_is_local(xe)) 3193 xe_len += 3194 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 3195 else 3196 xe_len += OCFS2_XATTR_ROOT_SIZE; 3197 name_value_len += xe_len; 3198 if (le16_to_cpu(xe->xe_name_offset) < name_offset) 3199 name_offset = le16_to_cpu(xe->xe_name_offset); 3200 } 3201 3202 /* 3203 * Now begin the modification to the new bucket. 3204 * 3205 * In the new bucket, We just move the xattr entry to the beginning 3206 * and don't touch the name/value. So there will be some holes in the 3207 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is 3208 * called. 3209 */ 3210 xe = &xh->xh_entries[start]; 3211 len = sizeof(struct ocfs2_xattr_entry) * (count - start); 3212 mlog(0, "mv xattr entry len %d from %d to %d\n", len, 3213 (int)((char *)xe - (char *)xh), 3214 (int)((char *)xh->xh_entries - (char *)xh)); 3215 memmove((char *)xh->xh_entries, (char *)xe, len); 3216 xe = &xh->xh_entries[count - start]; 3217 len = sizeof(struct ocfs2_xattr_entry) * start; 3218 memset((char *)xe, 0, len); 3219 3220 le16_add_cpu(&xh->xh_count, -start); 3221 le16_add_cpu(&xh->xh_name_value_len, -name_value_len); 3222 3223 /* Calculate xh_free_start for the new bucket. */ 3224 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE); 3225 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 3226 xe = &xh->xh_entries[i]; 3227 xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3228 if (ocfs2_xattr_is_local(xe)) 3229 xe_len += 3230 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 3231 else 3232 xe_len += OCFS2_XATTR_ROOT_SIZE; 3233 if (le16_to_cpu(xe->xe_name_offset) < 3234 le16_to_cpu(xh->xh_free_start)) 3235 xh->xh_free_start = xe->xe_name_offset; 3236 } 3237 3238 /* set xh->xh_num_buckets for the new xh. */ 3239 if (new_bucket_head) 3240 xh->xh_num_buckets = cpu_to_le16(1); 3241 else 3242 xh->xh_num_buckets = 0; 3243 3244 for (i = 0; i < blk_per_bucket; i++) { 3245 ocfs2_journal_dirty(handle, t_bhs[i]); 3246 if (ret) 3247 mlog_errno(ret); 3248 } 3249 3250 /* store the first_hash of the new bucket. */ 3251 if (first_hash) 3252 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash); 3253 3254 /* 3255 * Now only update the 1st block of the old bucket. 3256 * Please note that the entry has been sorted already above. 3257 */ 3258 xh = (struct ocfs2_xattr_header *)s_bhs[0]->b_data; 3259 memset(&xh->xh_entries[start], 0, 3260 sizeof(struct ocfs2_xattr_entry) * (count - start)); 3261 xh->xh_count = cpu_to_le16(start); 3262 xh->xh_free_start = cpu_to_le16(name_offset); 3263 xh->xh_name_value_len = cpu_to_le16(name_value_len); 3264 3265 ocfs2_journal_dirty(handle, s_bhs[0]); 3266 if (ret) 3267 mlog_errno(ret); 3268 3269 out: 3270 if (s_bhs) { 3271 for (i = 0; i < blk_per_bucket; i++) 3272 brelse(s_bhs[i]); 3273 } 3274 kfree(s_bhs); 3275 3276 if (t_bhs) { 3277 for (i = 0; i < blk_per_bucket; i++) 3278 brelse(t_bhs[i]); 3279 } 3280 kfree(t_bhs); 3281 3282 return ret; 3283 } 3284 3285 /* 3286 * Copy xattr from one bucket to another bucket. 3287 * 3288 * The caller must make sure that the journal transaction 3289 * has enough space for journaling. 3290 */ 3291 static int ocfs2_cp_xattr_bucket(struct inode *inode, 3292 handle_t *handle, 3293 u64 s_blkno, 3294 u64 t_blkno, 3295 int t_is_new) 3296 { 3297 int ret, i; 3298 int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3299 int blocksize = inode->i_sb->s_blocksize; 3300 struct buffer_head **s_bhs, **t_bhs = NULL; 3301 3302 BUG_ON(s_blkno == t_blkno); 3303 3304 mlog(0, "cp bucket %llu to %llu, target is %d\n", 3305 s_blkno, t_blkno, t_is_new); 3306 3307 s_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket, 3308 GFP_NOFS); 3309 if (!s_bhs) 3310 return -ENOMEM; 3311 3312 ret = ocfs2_read_xattr_bucket(inode, s_blkno, s_bhs, 0); 3313 if (ret) 3314 goto out; 3315 3316 t_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket, 3317 GFP_NOFS); 3318 if (!t_bhs) { 3319 ret = -ENOMEM; 3320 goto out; 3321 } 3322 3323 ret = ocfs2_read_xattr_bucket(inode, t_blkno, t_bhs, t_is_new); 3324 if (ret) 3325 goto out; 3326 3327 for (i = 0; i < blk_per_bucket; i++) { 3328 ret = ocfs2_journal_access(handle, inode, t_bhs[i], 3329 t_is_new ? 3330 OCFS2_JOURNAL_ACCESS_CREATE : 3331 OCFS2_JOURNAL_ACCESS_WRITE); 3332 if (ret) 3333 goto out; 3334 } 3335 3336 for (i = 0; i < blk_per_bucket; i++) { 3337 memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize); 3338 ocfs2_journal_dirty(handle, t_bhs[i]); 3339 } 3340 3341 out: 3342 if (s_bhs) { 3343 for (i = 0; i < blk_per_bucket; i++) 3344 brelse(s_bhs[i]); 3345 } 3346 kfree(s_bhs); 3347 3348 if (t_bhs) { 3349 for (i = 0; i < blk_per_bucket; i++) 3350 brelse(t_bhs[i]); 3351 } 3352 kfree(t_bhs); 3353 3354 return ret; 3355 } 3356 3357 /* 3358 * Copy one xattr cluster from src_blk to to_blk. 3359 * The to_blk will become the first bucket header of the cluster, so its 3360 * xh_num_buckets will be initialized as the bucket num in the cluster. 3361 */ 3362 static int ocfs2_cp_xattr_cluster(struct inode *inode, 3363 handle_t *handle, 3364 struct buffer_head *first_bh, 3365 u64 src_blk, 3366 u64 to_blk, 3367 u32 *first_hash) 3368 { 3369 int i, ret, credits; 3370 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3371 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 3372 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb); 3373 struct buffer_head *bh = NULL; 3374 struct ocfs2_xattr_header *xh; 3375 u64 to_blk_start = to_blk; 3376 3377 mlog(0, "cp xattrs from cluster %llu to %llu\n", src_blk, to_blk); 3378 3379 /* 3380 * We need to update the new cluster and 1 more for the update of 3381 * the 1st bucket of the previous extent rec. 3382 */ 3383 credits = bpc + 1; 3384 ret = ocfs2_extend_trans(handle, credits); 3385 if (ret) { 3386 mlog_errno(ret); 3387 goto out; 3388 } 3389 3390 ret = ocfs2_journal_access(handle, inode, first_bh, 3391 OCFS2_JOURNAL_ACCESS_WRITE); 3392 if (ret) { 3393 mlog_errno(ret); 3394 goto out; 3395 } 3396 3397 for (i = 0; i < num_buckets; i++) { 3398 ret = ocfs2_cp_xattr_bucket(inode, handle, 3399 src_blk, to_blk, 1); 3400 if (ret) { 3401 mlog_errno(ret); 3402 goto out; 3403 } 3404 3405 src_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3406 to_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3407 } 3408 3409 /* update the old bucket header. */ 3410 xh = (struct ocfs2_xattr_header *)first_bh->b_data; 3411 le16_add_cpu(&xh->xh_num_buckets, -num_buckets); 3412 3413 ocfs2_journal_dirty(handle, first_bh); 3414 3415 /* update the new bucket header. */ 3416 ret = ocfs2_read_block(inode, to_blk_start, &bh); 3417 if (ret < 0) { 3418 mlog_errno(ret); 3419 goto out; 3420 } 3421 3422 ret = ocfs2_journal_access(handle, inode, bh, 3423 OCFS2_JOURNAL_ACCESS_WRITE); 3424 if (ret) { 3425 mlog_errno(ret); 3426 goto out; 3427 } 3428 3429 xh = (struct ocfs2_xattr_header *)bh->b_data; 3430 xh->xh_num_buckets = cpu_to_le16(num_buckets); 3431 3432 ocfs2_journal_dirty(handle, bh); 3433 3434 if (first_hash) 3435 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash); 3436 out: 3437 brelse(bh); 3438 return ret; 3439 } 3440 3441 /* 3442 * Move half of the xattrs in this cluster to the new cluster. 3443 * This function should only be called when bucket size == cluster size. 3444 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead. 3445 */ 3446 static int ocfs2_half_xattr_cluster(struct inode *inode, 3447 handle_t *handle, 3448 u64 prev_blk, 3449 u64 new_blk, 3450 u32 *first_hash) 3451 { 3452 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3453 int ret, credits = 2 * blk_per_bucket; 3454 3455 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize); 3456 3457 ret = ocfs2_extend_trans(handle, credits); 3458 if (ret) { 3459 mlog_errno(ret); 3460 return ret; 3461 } 3462 3463 /* Move half of the xattr in start_blk to the next bucket. */ 3464 return ocfs2_half_xattr_bucket(inode, handle, prev_blk, 3465 new_blk, first_hash, 1); 3466 } 3467 3468 /* 3469 * Move some xattrs from the old cluster to the new one since they are not 3470 * contiguous in ocfs2 xattr tree. 3471 * 3472 * new_blk starts a new separate cluster, and we will move some xattrs from 3473 * prev_blk to it. v_start will be set as the first name hash value in this 3474 * new cluster so that it can be used as e_cpos during tree insertion and 3475 * don't collide with our original b-tree operations. first_bh and header_bh 3476 * will also be updated since they will be used in ocfs2_extend_xattr_bucket 3477 * to extend the insert bucket. 3478 * 3479 * The problem is how much xattr should we move to the new one and when should 3480 * we update first_bh and header_bh? 3481 * 1. If cluster size > bucket size, that means the previous cluster has more 3482 * than 1 bucket, so just move half nums of bucket into the new cluster and 3483 * update the first_bh and header_bh if the insert bucket has been moved 3484 * to the new cluster. 3485 * 2. If cluster_size == bucket_size: 3486 * a) If the previous extent rec has more than one cluster and the insert 3487 * place isn't in the last cluster, copy the entire last cluster to the 3488 * new one. This time, we don't need to upate the first_bh and header_bh 3489 * since they will not be moved into the new cluster. 3490 * b) Otherwise, move the bottom half of the xattrs in the last cluster into 3491 * the new one. And we set the extend flag to zero if the insert place is 3492 * moved into the new allocated cluster since no extend is needed. 3493 */ 3494 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode, 3495 handle_t *handle, 3496 struct buffer_head **first_bh, 3497 struct buffer_head **header_bh, 3498 u64 new_blk, 3499 u64 prev_blk, 3500 u32 prev_clusters, 3501 u32 *v_start, 3502 int *extend) 3503 { 3504 int ret = 0; 3505 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 3506 3507 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n", 3508 prev_blk, prev_clusters, new_blk); 3509 3510 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) 3511 ret = ocfs2_mv_xattr_bucket_cross_cluster(inode, 3512 handle, 3513 first_bh, 3514 header_bh, 3515 new_blk, 3516 prev_blk, 3517 prev_clusters, 3518 v_start); 3519 else { 3520 u64 last_blk = prev_blk + bpc * (prev_clusters - 1); 3521 3522 if (prev_clusters > 1 && (*header_bh)->b_blocknr != last_blk) 3523 ret = ocfs2_cp_xattr_cluster(inode, handle, *first_bh, 3524 last_blk, new_blk, 3525 v_start); 3526 else { 3527 ret = ocfs2_half_xattr_cluster(inode, handle, 3528 last_blk, new_blk, 3529 v_start); 3530 3531 if ((*header_bh)->b_blocknr == last_blk && extend) 3532 *extend = 0; 3533 } 3534 } 3535 3536 return ret; 3537 } 3538 3539 /* 3540 * Add a new cluster for xattr storage. 3541 * 3542 * If the new cluster is contiguous with the previous one, it will be 3543 * appended to the same extent record, and num_clusters will be updated. 3544 * If not, we will insert a new extent for it and move some xattrs in 3545 * the last cluster into the new allocated one. 3546 * We also need to limit the maximum size of a btree leaf, otherwise we'll 3547 * lose the benefits of hashing because we'll have to search large leaves. 3548 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize, 3549 * if it's bigger). 3550 * 3551 * first_bh is the first block of the previous extent rec and header_bh 3552 * indicates the bucket we will insert the new xattrs. They will be updated 3553 * when the header_bh is moved into the new cluster. 3554 */ 3555 static int ocfs2_add_new_xattr_cluster(struct inode *inode, 3556 struct buffer_head *root_bh, 3557 struct buffer_head **first_bh, 3558 struct buffer_head **header_bh, 3559 u32 *num_clusters, 3560 u32 prev_cpos, 3561 u64 prev_blkno, 3562 int *extend) 3563 { 3564 int ret, credits; 3565 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 3566 u32 prev_clusters = *num_clusters; 3567 u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0; 3568 u64 block; 3569 handle_t *handle = NULL; 3570 struct ocfs2_alloc_context *data_ac = NULL; 3571 struct ocfs2_alloc_context *meta_ac = NULL; 3572 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3573 struct ocfs2_extent_tree et; 3574 3575 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, " 3576 "previous xattr blkno = %llu\n", 3577 (unsigned long long)OCFS2_I(inode)->ip_blkno, 3578 prev_cpos, prev_blkno); 3579 3580 ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh); 3581 3582 ret = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0, 3583 &data_ac, &meta_ac); 3584 if (ret) { 3585 mlog_errno(ret); 3586 goto leave; 3587 } 3588 3589 credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el, 3590 clusters_to_add); 3591 handle = ocfs2_start_trans(osb, credits); 3592 if (IS_ERR(handle)) { 3593 ret = PTR_ERR(handle); 3594 handle = NULL; 3595 mlog_errno(ret); 3596 goto leave; 3597 } 3598 3599 ret = ocfs2_journal_access(handle, inode, root_bh, 3600 OCFS2_JOURNAL_ACCESS_WRITE); 3601 if (ret < 0) { 3602 mlog_errno(ret); 3603 goto leave; 3604 } 3605 3606 ret = __ocfs2_claim_clusters(osb, handle, data_ac, 1, 3607 clusters_to_add, &bit_off, &num_bits); 3608 if (ret < 0) { 3609 if (ret != -ENOSPC) 3610 mlog_errno(ret); 3611 goto leave; 3612 } 3613 3614 BUG_ON(num_bits > clusters_to_add); 3615 3616 block = ocfs2_clusters_to_blocks(osb->sb, bit_off); 3617 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n", 3618 num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno); 3619 3620 if (prev_blkno + prev_clusters * bpc == block && 3621 (prev_clusters + num_bits) << osb->s_clustersize_bits <= 3622 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) { 3623 /* 3624 * If this cluster is contiguous with the old one and 3625 * adding this new cluster, we don't surpass the limit of 3626 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be 3627 * initialized and used like other buckets in the previous 3628 * cluster. 3629 * So add it as a contiguous one. The caller will handle 3630 * its init process. 3631 */ 3632 v_start = prev_cpos + prev_clusters; 3633 *num_clusters = prev_clusters + num_bits; 3634 mlog(0, "Add contiguous %u clusters to previous extent rec.\n", 3635 num_bits); 3636 } else { 3637 ret = ocfs2_adjust_xattr_cross_cluster(inode, 3638 handle, 3639 first_bh, 3640 header_bh, 3641 block, 3642 prev_blkno, 3643 prev_clusters, 3644 &v_start, 3645 extend); 3646 if (ret) { 3647 mlog_errno(ret); 3648 goto leave; 3649 } 3650 } 3651 3652 if (handle->h_buffer_credits < credits) { 3653 /* 3654 * The journal has been restarted before, and don't 3655 * have enough space for the insertion, so extend it 3656 * here. 3657 */ 3658 ret = ocfs2_extend_trans(handle, credits); 3659 if (ret) { 3660 mlog_errno(ret); 3661 goto leave; 3662 } 3663 } 3664 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n", 3665 num_bits, block, v_start); 3666 ret = ocfs2_insert_extent(osb, handle, inode, &et, v_start, block, 3667 num_bits, 0, meta_ac); 3668 if (ret < 0) { 3669 mlog_errno(ret); 3670 goto leave; 3671 } 3672 3673 ret = ocfs2_journal_dirty(handle, root_bh); 3674 if (ret < 0) { 3675 mlog_errno(ret); 3676 goto leave; 3677 } 3678 3679 leave: 3680 if (handle) 3681 ocfs2_commit_trans(osb, handle); 3682 if (data_ac) 3683 ocfs2_free_alloc_context(data_ac); 3684 if (meta_ac) 3685 ocfs2_free_alloc_context(meta_ac); 3686 3687 return ret; 3688 } 3689 3690 /* 3691 * Extend a new xattr bucket and move xattrs to the end one by one until 3692 * We meet with start_bh. Only move half of the xattrs to the bucket after it. 3693 */ 3694 static int ocfs2_extend_xattr_bucket(struct inode *inode, 3695 struct buffer_head *first_bh, 3696 struct buffer_head *start_bh, 3697 u32 num_clusters) 3698 { 3699 int ret, credits; 3700 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3701 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3702 u64 start_blk = start_bh->b_blocknr, end_blk; 3703 u32 num_buckets = num_clusters * ocfs2_xattr_buckets_per_cluster(osb); 3704 handle_t *handle; 3705 struct ocfs2_xattr_header *first_xh = 3706 (struct ocfs2_xattr_header *)first_bh->b_data; 3707 u16 bucket = le16_to_cpu(first_xh->xh_num_buckets); 3708 3709 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting " 3710 "from %llu, len = %u\n", start_blk, 3711 (unsigned long long)first_bh->b_blocknr, num_clusters); 3712 3713 BUG_ON(bucket >= num_buckets); 3714 3715 end_blk = first_bh->b_blocknr + (bucket - 1) * blk_per_bucket; 3716 3717 /* 3718 * We will touch all the buckets after the start_bh(include it). 3719 * Add one more bucket and modify the first_bh. 3720 */ 3721 credits = end_blk - start_blk + 2 * blk_per_bucket + 1; 3722 handle = ocfs2_start_trans(osb, credits); 3723 if (IS_ERR(handle)) { 3724 ret = PTR_ERR(handle); 3725 handle = NULL; 3726 mlog_errno(ret); 3727 goto out; 3728 } 3729 3730 ret = ocfs2_journal_access(handle, inode, first_bh, 3731 OCFS2_JOURNAL_ACCESS_WRITE); 3732 if (ret) { 3733 mlog_errno(ret); 3734 goto commit; 3735 } 3736 3737 while (end_blk != start_blk) { 3738 ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk, 3739 end_blk + blk_per_bucket, 0); 3740 if (ret) 3741 goto commit; 3742 end_blk -= blk_per_bucket; 3743 } 3744 3745 /* Move half of the xattr in start_blk to the next bucket. */ 3746 ret = ocfs2_half_xattr_bucket(inode, handle, start_blk, 3747 start_blk + blk_per_bucket, NULL, 0); 3748 3749 le16_add_cpu(&first_xh->xh_num_buckets, 1); 3750 ocfs2_journal_dirty(handle, first_bh); 3751 3752 commit: 3753 ocfs2_commit_trans(osb, handle); 3754 out: 3755 return ret; 3756 } 3757 3758 /* 3759 * Add new xattr bucket in an extent record and adjust the buckets accordingly. 3760 * xb_bh is the ocfs2_xattr_block. 3761 * We will move all the buckets starting from header_bh to the next place. As 3762 * for this one, half num of its xattrs will be moved to the next one. 3763 * 3764 * We will allocate a new cluster if current cluster is full and adjust 3765 * header_bh and first_bh if the insert place is moved to the new cluster. 3766 */ 3767 static int ocfs2_add_new_xattr_bucket(struct inode *inode, 3768 struct buffer_head *xb_bh, 3769 struct buffer_head *header_bh) 3770 { 3771 struct ocfs2_xattr_header *first_xh = NULL; 3772 struct buffer_head *first_bh = NULL; 3773 struct ocfs2_xattr_block *xb = 3774 (struct ocfs2_xattr_block *)xb_bh->b_data; 3775 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root; 3776 struct ocfs2_extent_list *el = &xb_root->xt_list; 3777 struct ocfs2_xattr_header *xh = 3778 (struct ocfs2_xattr_header *)header_bh->b_data; 3779 u32 name_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash); 3780 struct super_block *sb = inode->i_sb; 3781 struct ocfs2_super *osb = OCFS2_SB(sb); 3782 int ret, num_buckets, extend = 1; 3783 u64 p_blkno; 3784 u32 e_cpos, num_clusters; 3785 3786 mlog(0, "Add new xattr bucket starting form %llu\n", 3787 (unsigned long long)header_bh->b_blocknr); 3788 3789 /* 3790 * Add refrence for header_bh here because it may be 3791 * changed in ocfs2_add_new_xattr_cluster and we need 3792 * to free it in the end. 3793 */ 3794 get_bh(header_bh); 3795 3796 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos, 3797 &num_clusters, el); 3798 if (ret) { 3799 mlog_errno(ret); 3800 goto out; 3801 } 3802 3803 ret = ocfs2_read_block(inode, p_blkno, &first_bh); 3804 if (ret) { 3805 mlog_errno(ret); 3806 goto out; 3807 } 3808 3809 num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters; 3810 first_xh = (struct ocfs2_xattr_header *)first_bh->b_data; 3811 3812 if (num_buckets == le16_to_cpu(first_xh->xh_num_buckets)) { 3813 ret = ocfs2_add_new_xattr_cluster(inode, 3814 xb_bh, 3815 &first_bh, 3816 &header_bh, 3817 &num_clusters, 3818 e_cpos, 3819 p_blkno, 3820 &extend); 3821 if (ret) { 3822 mlog_errno(ret); 3823 goto out; 3824 } 3825 } 3826 3827 if (extend) 3828 ret = ocfs2_extend_xattr_bucket(inode, 3829 first_bh, 3830 header_bh, 3831 num_clusters); 3832 if (ret) 3833 mlog_errno(ret); 3834 out: 3835 brelse(first_bh); 3836 brelse(header_bh); 3837 return ret; 3838 } 3839 3840 static inline char *ocfs2_xattr_bucket_get_val(struct inode *inode, 3841 struct ocfs2_xattr_bucket *bucket, 3842 int offs) 3843 { 3844 int block_off = offs >> inode->i_sb->s_blocksize_bits; 3845 3846 offs = offs % inode->i_sb->s_blocksize; 3847 return bucket->bhs[block_off]->b_data + offs; 3848 } 3849 3850 /* 3851 * Handle the normal xattr set, including replace, delete and new. 3852 * 3853 * Note: "local" indicates the real data's locality. So we can't 3854 * just its bucket locality by its length. 3855 */ 3856 static void ocfs2_xattr_set_entry_normal(struct inode *inode, 3857 struct ocfs2_xattr_info *xi, 3858 struct ocfs2_xattr_search *xs, 3859 u32 name_hash, 3860 int local) 3861 { 3862 struct ocfs2_xattr_entry *last, *xe; 3863 int name_len = strlen(xi->name); 3864 struct ocfs2_xattr_header *xh = xs->header; 3865 u16 count = le16_to_cpu(xh->xh_count), start; 3866 size_t blocksize = inode->i_sb->s_blocksize; 3867 char *val; 3868 size_t offs, size, new_size; 3869 3870 last = &xh->xh_entries[count]; 3871 if (!xs->not_found) { 3872 xe = xs->here; 3873 offs = le16_to_cpu(xe->xe_name_offset); 3874 if (ocfs2_xattr_is_local(xe)) 3875 size = OCFS2_XATTR_SIZE(name_len) + 3876 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 3877 else 3878 size = OCFS2_XATTR_SIZE(name_len) + 3879 OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE); 3880 3881 /* 3882 * If the new value will be stored outside, xi->value has been 3883 * initalized as an empty ocfs2_xattr_value_root, and the same 3884 * goes with xi->value_len, so we can set new_size safely here. 3885 * See ocfs2_xattr_set_in_bucket. 3886 */ 3887 new_size = OCFS2_XATTR_SIZE(name_len) + 3888 OCFS2_XATTR_SIZE(xi->value_len); 3889 3890 le16_add_cpu(&xh->xh_name_value_len, -size); 3891 if (xi->value) { 3892 if (new_size > size) 3893 goto set_new_name_value; 3894 3895 /* Now replace the old value with new one. */ 3896 if (local) 3897 xe->xe_value_size = cpu_to_le64(xi->value_len); 3898 else 3899 xe->xe_value_size = 0; 3900 3901 val = ocfs2_xattr_bucket_get_val(inode, 3902 &xs->bucket, offs); 3903 memset(val + OCFS2_XATTR_SIZE(name_len), 0, 3904 size - OCFS2_XATTR_SIZE(name_len)); 3905 if (OCFS2_XATTR_SIZE(xi->value_len) > 0) 3906 memcpy(val + OCFS2_XATTR_SIZE(name_len), 3907 xi->value, xi->value_len); 3908 3909 le16_add_cpu(&xh->xh_name_value_len, new_size); 3910 ocfs2_xattr_set_local(xe, local); 3911 return; 3912 } else { 3913 /* 3914 * Remove the old entry if there is more than one. 3915 * We don't remove the last entry so that we can 3916 * use it to indicate the hash value of the empty 3917 * bucket. 3918 */ 3919 last -= 1; 3920 le16_add_cpu(&xh->xh_count, -1); 3921 if (xh->xh_count) { 3922 memmove(xe, xe + 1, 3923 (void *)last - (void *)xe); 3924 memset(last, 0, 3925 sizeof(struct ocfs2_xattr_entry)); 3926 } else 3927 xh->xh_free_start = 3928 cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE); 3929 3930 return; 3931 } 3932 } else { 3933 /* find a new entry for insert. */ 3934 int low = 0, high = count - 1, tmp; 3935 struct ocfs2_xattr_entry *tmp_xe; 3936 3937 while (low <= high && count) { 3938 tmp = (low + high) / 2; 3939 tmp_xe = &xh->xh_entries[tmp]; 3940 3941 if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash)) 3942 low = tmp + 1; 3943 else if (name_hash < 3944 le32_to_cpu(tmp_xe->xe_name_hash)) 3945 high = tmp - 1; 3946 else { 3947 low = tmp; 3948 break; 3949 } 3950 } 3951 3952 xe = &xh->xh_entries[low]; 3953 if (low != count) 3954 memmove(xe + 1, xe, (void *)last - (void *)xe); 3955 3956 le16_add_cpu(&xh->xh_count, 1); 3957 memset(xe, 0, sizeof(struct ocfs2_xattr_entry)); 3958 xe->xe_name_hash = cpu_to_le32(name_hash); 3959 xe->xe_name_len = name_len; 3960 ocfs2_xattr_set_type(xe, xi->name_index); 3961 } 3962 3963 set_new_name_value: 3964 /* Insert the new name+value. */ 3965 size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(xi->value_len); 3966 3967 /* 3968 * We must make sure that the name/value pair 3969 * exists in the same block. 3970 */ 3971 offs = le16_to_cpu(xh->xh_free_start); 3972 start = offs - size; 3973 3974 if (start >> inode->i_sb->s_blocksize_bits != 3975 (offs - 1) >> inode->i_sb->s_blocksize_bits) { 3976 offs = offs - offs % blocksize; 3977 xh->xh_free_start = cpu_to_le16(offs); 3978 } 3979 3980 val = ocfs2_xattr_bucket_get_val(inode, 3981 &xs->bucket, offs - size); 3982 xe->xe_name_offset = cpu_to_le16(offs - size); 3983 3984 memset(val, 0, size); 3985 memcpy(val, xi->name, name_len); 3986 memcpy(val + OCFS2_XATTR_SIZE(name_len), xi->value, xi->value_len); 3987 3988 xe->xe_value_size = cpu_to_le64(xi->value_len); 3989 ocfs2_xattr_set_local(xe, local); 3990 xs->here = xe; 3991 le16_add_cpu(&xh->xh_free_start, -size); 3992 le16_add_cpu(&xh->xh_name_value_len, size); 3993 3994 return; 3995 } 3996 3997 static int ocfs2_xattr_bucket_handle_journal(struct inode *inode, 3998 handle_t *handle, 3999 struct ocfs2_xattr_search *xs, 4000 struct buffer_head **bhs, 4001 u16 bh_num) 4002 { 4003 int ret = 0, off, block_off; 4004 struct ocfs2_xattr_entry *xe = xs->here; 4005 4006 /* 4007 * First calculate all the blocks we should journal_access 4008 * and journal_dirty. The first block should always be touched. 4009 */ 4010 ret = ocfs2_journal_dirty(handle, bhs[0]); 4011 if (ret) 4012 mlog_errno(ret); 4013 4014 /* calc the data. */ 4015 off = le16_to_cpu(xe->xe_name_offset); 4016 block_off = off >> inode->i_sb->s_blocksize_bits; 4017 ret = ocfs2_journal_dirty(handle, bhs[block_off]); 4018 if (ret) 4019 mlog_errno(ret); 4020 4021 return ret; 4022 } 4023 4024 /* 4025 * Set the xattr entry in the specified bucket. 4026 * The bucket is indicated by xs->bucket and it should have the enough 4027 * space for the xattr insertion. 4028 */ 4029 static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode, 4030 struct ocfs2_xattr_info *xi, 4031 struct ocfs2_xattr_search *xs, 4032 u32 name_hash, 4033 int local) 4034 { 4035 int i, ret; 4036 handle_t *handle = NULL; 4037 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4038 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4039 4040 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n", 4041 (unsigned long)xi->value_len, xi->name_index, 4042 (unsigned long long)xs->bucket.bhs[0]->b_blocknr); 4043 4044 if (!xs->bucket.bhs[1]) { 4045 ret = ocfs2_read_blocks(inode, 4046 xs->bucket.bhs[0]->b_blocknr + 1, 4047 blk_per_bucket - 1, &xs->bucket.bhs[1], 4048 0); 4049 if (ret) { 4050 mlog_errno(ret); 4051 goto out; 4052 } 4053 } 4054 4055 handle = ocfs2_start_trans(osb, blk_per_bucket); 4056 if (IS_ERR(handle)) { 4057 ret = PTR_ERR(handle); 4058 handle = NULL; 4059 mlog_errno(ret); 4060 goto out; 4061 } 4062 4063 for (i = 0; i < blk_per_bucket; i++) { 4064 ret = ocfs2_journal_access(handle, inode, xs->bucket.bhs[i], 4065 OCFS2_JOURNAL_ACCESS_WRITE); 4066 if (ret < 0) { 4067 mlog_errno(ret); 4068 goto out; 4069 } 4070 } 4071 4072 ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local); 4073 4074 /*Only dirty the blocks we have touched in set xattr. */ 4075 ret = ocfs2_xattr_bucket_handle_journal(inode, handle, xs, 4076 xs->bucket.bhs, blk_per_bucket); 4077 if (ret) 4078 mlog_errno(ret); 4079 out: 4080 ocfs2_commit_trans(osb, handle); 4081 4082 return ret; 4083 } 4084 4085 static int ocfs2_xattr_value_update_size(struct inode *inode, 4086 struct buffer_head *xe_bh, 4087 struct ocfs2_xattr_entry *xe, 4088 u64 new_size) 4089 { 4090 int ret; 4091 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4092 handle_t *handle = NULL; 4093 4094 handle = ocfs2_start_trans(osb, 1); 4095 if (handle == NULL) { 4096 ret = -ENOMEM; 4097 mlog_errno(ret); 4098 goto out; 4099 } 4100 4101 ret = ocfs2_journal_access(handle, inode, xe_bh, 4102 OCFS2_JOURNAL_ACCESS_WRITE); 4103 if (ret < 0) { 4104 mlog_errno(ret); 4105 goto out_commit; 4106 } 4107 4108 xe->xe_value_size = cpu_to_le64(new_size); 4109 4110 ret = ocfs2_journal_dirty(handle, xe_bh); 4111 if (ret < 0) 4112 mlog_errno(ret); 4113 4114 out_commit: 4115 ocfs2_commit_trans(osb, handle); 4116 out: 4117 return ret; 4118 } 4119 4120 /* 4121 * Truncate the specified xe_off entry in xattr bucket. 4122 * bucket is indicated by header_bh and len is the new length. 4123 * Both the ocfs2_xattr_value_root and the entry will be updated here. 4124 * 4125 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed. 4126 */ 4127 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode, 4128 struct buffer_head *header_bh, 4129 int xe_off, 4130 int len) 4131 { 4132 int ret, offset; 4133 u64 value_blk; 4134 struct buffer_head *value_bh = NULL; 4135 struct ocfs2_xattr_value_root *xv; 4136 struct ocfs2_xattr_entry *xe; 4137 struct ocfs2_xattr_header *xh = 4138 (struct ocfs2_xattr_header *)header_bh->b_data; 4139 size_t blocksize = inode->i_sb->s_blocksize; 4140 4141 xe = &xh->xh_entries[xe_off]; 4142 4143 BUG_ON(!xe || ocfs2_xattr_is_local(xe)); 4144 4145 offset = le16_to_cpu(xe->xe_name_offset) + 4146 OCFS2_XATTR_SIZE(xe->xe_name_len); 4147 4148 value_blk = offset / blocksize; 4149 4150 /* We don't allow ocfs2_xattr_value to be stored in different block. */ 4151 BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize); 4152 value_blk += header_bh->b_blocknr; 4153 4154 ret = ocfs2_read_block(inode, value_blk, &value_bh); 4155 if (ret) { 4156 mlog_errno(ret); 4157 goto out; 4158 } 4159 4160 xv = (struct ocfs2_xattr_value_root *) 4161 (value_bh->b_data + offset % blocksize); 4162 4163 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n", 4164 xe_off, (unsigned long long)header_bh->b_blocknr, len); 4165 ret = ocfs2_xattr_value_truncate(inode, value_bh, xv, len); 4166 if (ret) { 4167 mlog_errno(ret); 4168 goto out; 4169 } 4170 4171 ret = ocfs2_xattr_value_update_size(inode, header_bh, xe, len); 4172 if (ret) { 4173 mlog_errno(ret); 4174 goto out; 4175 } 4176 4177 out: 4178 brelse(value_bh); 4179 return ret; 4180 } 4181 4182 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode, 4183 struct ocfs2_xattr_search *xs, 4184 int len) 4185 { 4186 int ret, offset; 4187 struct ocfs2_xattr_entry *xe = xs->here; 4188 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base; 4189 4190 BUG_ON(!xs->bucket.bhs[0] || !xe || ocfs2_xattr_is_local(xe)); 4191 4192 offset = xe - xh->xh_entries; 4193 ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket.bhs[0], 4194 offset, len); 4195 if (ret) 4196 mlog_errno(ret); 4197 4198 return ret; 4199 } 4200 4201 static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode, 4202 struct ocfs2_xattr_search *xs, 4203 char *val, 4204 int value_len) 4205 { 4206 int offset; 4207 struct ocfs2_xattr_value_root *xv; 4208 struct ocfs2_xattr_entry *xe = xs->here; 4209 4210 BUG_ON(!xs->base || !xe || ocfs2_xattr_is_local(xe)); 4211 4212 offset = le16_to_cpu(xe->xe_name_offset) + 4213 OCFS2_XATTR_SIZE(xe->xe_name_len); 4214 4215 xv = (struct ocfs2_xattr_value_root *)(xs->base + offset); 4216 4217 return __ocfs2_xattr_set_value_outside(inode, xv, val, value_len); 4218 } 4219 4220 static int ocfs2_rm_xattr_cluster(struct inode *inode, 4221 struct buffer_head *root_bh, 4222 u64 blkno, 4223 u32 cpos, 4224 u32 len) 4225 { 4226 int ret; 4227 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4228 struct inode *tl_inode = osb->osb_tl_inode; 4229 handle_t *handle; 4230 struct ocfs2_xattr_block *xb = 4231 (struct ocfs2_xattr_block *)root_bh->b_data; 4232 struct ocfs2_alloc_context *meta_ac = NULL; 4233 struct ocfs2_cached_dealloc_ctxt dealloc; 4234 struct ocfs2_extent_tree et; 4235 4236 ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh); 4237 4238 ocfs2_init_dealloc_ctxt(&dealloc); 4239 4240 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n", 4241 cpos, len, (unsigned long long)blkno); 4242 4243 ocfs2_remove_xattr_clusters_from_cache(inode, blkno, len); 4244 4245 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac); 4246 if (ret) { 4247 mlog_errno(ret); 4248 return ret; 4249 } 4250 4251 mutex_lock(&tl_inode->i_mutex); 4252 4253 if (ocfs2_truncate_log_needs_flush(osb)) { 4254 ret = __ocfs2_flush_truncate_log(osb); 4255 if (ret < 0) { 4256 mlog_errno(ret); 4257 goto out; 4258 } 4259 } 4260 4261 handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS); 4262 if (handle == NULL) { 4263 ret = -ENOMEM; 4264 mlog_errno(ret); 4265 goto out; 4266 } 4267 4268 ret = ocfs2_journal_access(handle, inode, root_bh, 4269 OCFS2_JOURNAL_ACCESS_WRITE); 4270 if (ret) { 4271 mlog_errno(ret); 4272 goto out_commit; 4273 } 4274 4275 ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac, 4276 &dealloc); 4277 if (ret) { 4278 mlog_errno(ret); 4279 goto out_commit; 4280 } 4281 4282 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len); 4283 4284 ret = ocfs2_journal_dirty(handle, root_bh); 4285 if (ret) { 4286 mlog_errno(ret); 4287 goto out_commit; 4288 } 4289 4290 ret = ocfs2_truncate_log_append(osb, handle, blkno, len); 4291 if (ret) 4292 mlog_errno(ret); 4293 4294 out_commit: 4295 ocfs2_commit_trans(osb, handle); 4296 out: 4297 ocfs2_schedule_truncate_log_flush(osb, 1); 4298 4299 mutex_unlock(&tl_inode->i_mutex); 4300 4301 if (meta_ac) 4302 ocfs2_free_alloc_context(meta_ac); 4303 4304 ocfs2_run_deallocs(osb, &dealloc); 4305 4306 return ret; 4307 } 4308 4309 static void ocfs2_xattr_bucket_remove_xs(struct inode *inode, 4310 struct ocfs2_xattr_search *xs) 4311 { 4312 handle_t *handle = NULL; 4313 struct ocfs2_xattr_header *xh = xs->bucket.xh; 4314 struct ocfs2_xattr_entry *last = &xh->xh_entries[ 4315 le16_to_cpu(xh->xh_count) - 1]; 4316 int ret = 0; 4317 4318 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1); 4319 if (IS_ERR(handle)) { 4320 ret = PTR_ERR(handle); 4321 mlog_errno(ret); 4322 return; 4323 } 4324 4325 ret = ocfs2_journal_access(handle, inode, xs->bucket.bhs[0], 4326 OCFS2_JOURNAL_ACCESS_WRITE); 4327 if (ret) { 4328 mlog_errno(ret); 4329 goto out_commit; 4330 } 4331 4332 /* Remove the old entry. */ 4333 memmove(xs->here, xs->here + 1, 4334 (void *)last - (void *)xs->here); 4335 memset(last, 0, sizeof(struct ocfs2_xattr_entry)); 4336 le16_add_cpu(&xh->xh_count, -1); 4337 4338 ret = ocfs2_journal_dirty(handle, xs->bucket.bhs[0]); 4339 if (ret < 0) 4340 mlog_errno(ret); 4341 out_commit: 4342 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 4343 } 4344 4345 /* 4346 * Set the xattr name/value in the bucket specified in xs. 4347 * 4348 * As the new value in xi may be stored in the bucket or in an outside cluster, 4349 * we divide the whole process into 3 steps: 4350 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket) 4351 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs) 4352 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside) 4353 * 4. If the clusters for the new outside value can't be allocated, we need 4354 * to free the xattr we allocated in set. 4355 */ 4356 static int ocfs2_xattr_set_in_bucket(struct inode *inode, 4357 struct ocfs2_xattr_info *xi, 4358 struct ocfs2_xattr_search *xs) 4359 { 4360 int ret, local = 1; 4361 size_t value_len; 4362 char *val = (char *)xi->value; 4363 struct ocfs2_xattr_entry *xe = xs->here; 4364 u32 name_hash = ocfs2_xattr_name_hash(inode, xi->name, 4365 strlen(xi->name)); 4366 4367 if (!xs->not_found && !ocfs2_xattr_is_local(xe)) { 4368 /* 4369 * We need to truncate the xattr storage first. 4370 * 4371 * If both the old and new value are stored to 4372 * outside block, we only need to truncate 4373 * the storage and then set the value outside. 4374 * 4375 * If the new value should be stored within block, 4376 * we should free all the outside block first and 4377 * the modification to the xattr block will be done 4378 * by following steps. 4379 */ 4380 if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) 4381 value_len = xi->value_len; 4382 else 4383 value_len = 0; 4384 4385 ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs, 4386 value_len); 4387 if (ret) 4388 goto out; 4389 4390 if (value_len) 4391 goto set_value_outside; 4392 } 4393 4394 value_len = xi->value_len; 4395 /* So we have to handle the inside block change now. */ 4396 if (value_len > OCFS2_XATTR_INLINE_SIZE) { 4397 /* 4398 * If the new value will be stored outside of block, 4399 * initalize a new empty value root and insert it first. 4400 */ 4401 local = 0; 4402 xi->value = &def_xv; 4403 xi->value_len = OCFS2_XATTR_ROOT_SIZE; 4404 } 4405 4406 ret = ocfs2_xattr_set_entry_in_bucket(inode, xi, xs, name_hash, local); 4407 if (ret) { 4408 mlog_errno(ret); 4409 goto out; 4410 } 4411 4412 if (value_len <= OCFS2_XATTR_INLINE_SIZE) 4413 goto out; 4414 4415 /* allocate the space now for the outside block storage. */ 4416 ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs, 4417 value_len); 4418 if (ret) { 4419 mlog_errno(ret); 4420 4421 if (xs->not_found) { 4422 /* 4423 * We can't allocate enough clusters for outside 4424 * storage and we have allocated xattr already, 4425 * so need to remove it. 4426 */ 4427 ocfs2_xattr_bucket_remove_xs(inode, xs); 4428 } 4429 goto out; 4430 } 4431 4432 set_value_outside: 4433 ret = ocfs2_xattr_bucket_set_value_outside(inode, xs, val, value_len); 4434 out: 4435 return ret; 4436 } 4437 4438 /* check whether the xattr bucket is filled up with the same hash value. */ 4439 static int ocfs2_check_xattr_bucket_collision(struct inode *inode, 4440 struct ocfs2_xattr_bucket *bucket) 4441 { 4442 struct ocfs2_xattr_header *xh = bucket->xh; 4443 4444 if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash == 4445 xh->xh_entries[0].xe_name_hash) { 4446 mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, " 4447 "hash = %u\n", 4448 (unsigned long long)bucket->bhs[0]->b_blocknr, 4449 le32_to_cpu(xh->xh_entries[0].xe_name_hash)); 4450 return -ENOSPC; 4451 } 4452 4453 return 0; 4454 } 4455 4456 static int ocfs2_xattr_set_entry_index_block(struct inode *inode, 4457 struct ocfs2_xattr_info *xi, 4458 struct ocfs2_xattr_search *xs) 4459 { 4460 struct ocfs2_xattr_header *xh; 4461 struct ocfs2_xattr_entry *xe; 4462 u16 count, header_size, xh_free_start; 4463 int i, free, max_free, need, old; 4464 size_t value_size = 0, name_len = strlen(xi->name); 4465 size_t blocksize = inode->i_sb->s_blocksize; 4466 int ret, allocation = 0; 4467 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4468 4469 mlog_entry("Set xattr %s in xattr index block\n", xi->name); 4470 4471 try_again: 4472 xh = xs->header; 4473 count = le16_to_cpu(xh->xh_count); 4474 xh_free_start = le16_to_cpu(xh->xh_free_start); 4475 header_size = sizeof(struct ocfs2_xattr_header) + 4476 count * sizeof(struct ocfs2_xattr_entry); 4477 max_free = OCFS2_XATTR_BUCKET_SIZE - 4478 le16_to_cpu(xh->xh_name_value_len) - header_size; 4479 4480 mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size " 4481 "of %u which exceed block size\n", 4482 (unsigned long long)xs->bucket.bhs[0]->b_blocknr, 4483 header_size); 4484 4485 if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) 4486 value_size = OCFS2_XATTR_ROOT_SIZE; 4487 else if (xi->value) 4488 value_size = OCFS2_XATTR_SIZE(xi->value_len); 4489 4490 if (xs->not_found) 4491 need = sizeof(struct ocfs2_xattr_entry) + 4492 OCFS2_XATTR_SIZE(name_len) + value_size; 4493 else { 4494 need = value_size + OCFS2_XATTR_SIZE(name_len); 4495 4496 /* 4497 * We only replace the old value if the new length is smaller 4498 * than the old one. Otherwise we will allocate new space in the 4499 * bucket to store it. 4500 */ 4501 xe = xs->here; 4502 if (ocfs2_xattr_is_local(xe)) 4503 old = OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 4504 else 4505 old = OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE); 4506 4507 if (old >= value_size) 4508 need = 0; 4509 } 4510 4511 free = xh_free_start - header_size; 4512 /* 4513 * We need to make sure the new name/value pair 4514 * can exist in the same block. 4515 */ 4516 if (xh_free_start % blocksize < need) 4517 free -= xh_free_start % blocksize; 4518 4519 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, " 4520 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len =" 4521 " %u\n", xs->not_found, 4522 (unsigned long long)xs->bucket.bhs[0]->b_blocknr, 4523 free, need, max_free, le16_to_cpu(xh->xh_free_start), 4524 le16_to_cpu(xh->xh_name_value_len)); 4525 4526 if (free < need || count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) { 4527 if (need <= max_free && 4528 count < ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) { 4529 /* 4530 * We can create the space by defragment. Since only the 4531 * name/value will be moved, the xe shouldn't be changed 4532 * in xs. 4533 */ 4534 ret = ocfs2_defrag_xattr_bucket(inode, &xs->bucket); 4535 if (ret) { 4536 mlog_errno(ret); 4537 goto out; 4538 } 4539 4540 xh_free_start = le16_to_cpu(xh->xh_free_start); 4541 free = xh_free_start - header_size; 4542 if (xh_free_start % blocksize < need) 4543 free -= xh_free_start % blocksize; 4544 4545 if (free >= need) 4546 goto xattr_set; 4547 4548 mlog(0, "Can't get enough space for xattr insert by " 4549 "defragment. Need %u bytes, but we have %d, so " 4550 "allocate new bucket for it.\n", need, free); 4551 } 4552 4553 /* 4554 * We have to add new buckets or clusters and one 4555 * allocation should leave us enough space for insert. 4556 */ 4557 BUG_ON(allocation); 4558 4559 /* 4560 * We do not allow for overlapping ranges between buckets. And 4561 * the maximum number of collisions we will allow for then is 4562 * one bucket's worth, so check it here whether we need to 4563 * add a new bucket for the insert. 4564 */ 4565 ret = ocfs2_check_xattr_bucket_collision(inode, &xs->bucket); 4566 if (ret) { 4567 mlog_errno(ret); 4568 goto out; 4569 } 4570 4571 ret = ocfs2_add_new_xattr_bucket(inode, 4572 xs->xattr_bh, 4573 xs->bucket.bhs[0]); 4574 if (ret) { 4575 mlog_errno(ret); 4576 goto out; 4577 } 4578 4579 for (i = 0; i < blk_per_bucket; i++) 4580 brelse(xs->bucket.bhs[i]); 4581 4582 memset(&xs->bucket, 0, sizeof(xs->bucket)); 4583 4584 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh, 4585 xi->name_index, 4586 xi->name, xs); 4587 if (ret && ret != -ENODATA) 4588 goto out; 4589 xs->not_found = ret; 4590 allocation = 1; 4591 goto try_again; 4592 } 4593 4594 xattr_set: 4595 ret = ocfs2_xattr_set_in_bucket(inode, xi, xs); 4596 out: 4597 mlog_exit(ret); 4598 return ret; 4599 } 4600 4601 static int ocfs2_delete_xattr_in_bucket(struct inode *inode, 4602 struct ocfs2_xattr_bucket *bucket, 4603 void *para) 4604 { 4605 int ret = 0; 4606 struct ocfs2_xattr_header *xh = bucket->xh; 4607 u16 i; 4608 struct ocfs2_xattr_entry *xe; 4609 4610 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 4611 xe = &xh->xh_entries[i]; 4612 if (ocfs2_xattr_is_local(xe)) 4613 continue; 4614 4615 ret = ocfs2_xattr_bucket_value_truncate(inode, 4616 bucket->bhs[0], 4617 i, 0); 4618 if (ret) { 4619 mlog_errno(ret); 4620 break; 4621 } 4622 } 4623 4624 return ret; 4625 } 4626 4627 static int ocfs2_delete_xattr_index_block(struct inode *inode, 4628 struct buffer_head *xb_bh) 4629 { 4630 struct ocfs2_xattr_block *xb = 4631 (struct ocfs2_xattr_block *)xb_bh->b_data; 4632 struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list; 4633 int ret = 0; 4634 u32 name_hash = UINT_MAX, e_cpos, num_clusters; 4635 u64 p_blkno; 4636 4637 if (le16_to_cpu(el->l_next_free_rec) == 0) 4638 return 0; 4639 4640 while (name_hash > 0) { 4641 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, 4642 &e_cpos, &num_clusters, el); 4643 if (ret) { 4644 mlog_errno(ret); 4645 goto out; 4646 } 4647 4648 ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters, 4649 ocfs2_delete_xattr_in_bucket, 4650 NULL); 4651 if (ret) { 4652 mlog_errno(ret); 4653 goto out; 4654 } 4655 4656 ret = ocfs2_rm_xattr_cluster(inode, xb_bh, 4657 p_blkno, e_cpos, num_clusters); 4658 if (ret) { 4659 mlog_errno(ret); 4660 break; 4661 } 4662 4663 if (e_cpos == 0) 4664 break; 4665 4666 name_hash = e_cpos - 1; 4667 } 4668 4669 out: 4670 return ret; 4671 } 4672 4673 /* 4674 * 'trusted' attributes support 4675 */ 4676 static size_t ocfs2_xattr_trusted_list(struct inode *inode, char *list, 4677 size_t list_size, const char *name, 4678 size_t name_len) 4679 { 4680 const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN; 4681 const size_t total_len = prefix_len + name_len + 1; 4682 4683 if (list && total_len <= list_size) { 4684 memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len); 4685 memcpy(list + prefix_len, name, name_len); 4686 list[prefix_len + name_len] = '\0'; 4687 } 4688 return total_len; 4689 } 4690 4691 static int ocfs2_xattr_trusted_get(struct inode *inode, const char *name, 4692 void *buffer, size_t size) 4693 { 4694 if (strcmp(name, "") == 0) 4695 return -EINVAL; 4696 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED, name, 4697 buffer, size); 4698 } 4699 4700 static int ocfs2_xattr_trusted_set(struct inode *inode, const char *name, 4701 const void *value, size_t size, int flags) 4702 { 4703 if (strcmp(name, "") == 0) 4704 return -EINVAL; 4705 4706 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_TRUSTED, name, value, 4707 size, flags); 4708 } 4709 4710 struct xattr_handler ocfs2_xattr_trusted_handler = { 4711 .prefix = XATTR_TRUSTED_PREFIX, 4712 .list = ocfs2_xattr_trusted_list, 4713 .get = ocfs2_xattr_trusted_get, 4714 .set = ocfs2_xattr_trusted_set, 4715 }; 4716 4717 /* 4718 * 'user' attributes support 4719 */ 4720 static size_t ocfs2_xattr_user_list(struct inode *inode, char *list, 4721 size_t list_size, const char *name, 4722 size_t name_len) 4723 { 4724 const size_t prefix_len = XATTR_USER_PREFIX_LEN; 4725 const size_t total_len = prefix_len + name_len + 1; 4726 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4727 4728 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 4729 return 0; 4730 4731 if (list && total_len <= list_size) { 4732 memcpy(list, XATTR_USER_PREFIX, prefix_len); 4733 memcpy(list + prefix_len, name, name_len); 4734 list[prefix_len + name_len] = '\0'; 4735 } 4736 return total_len; 4737 } 4738 4739 static int ocfs2_xattr_user_get(struct inode *inode, const char *name, 4740 void *buffer, size_t size) 4741 { 4742 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4743 4744 if (strcmp(name, "") == 0) 4745 return -EINVAL; 4746 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 4747 return -EOPNOTSUPP; 4748 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name, 4749 buffer, size); 4750 } 4751 4752 static int ocfs2_xattr_user_set(struct inode *inode, const char *name, 4753 const void *value, size_t size, int flags) 4754 { 4755 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4756 4757 if (strcmp(name, "") == 0) 4758 return -EINVAL; 4759 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 4760 return -EOPNOTSUPP; 4761 4762 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_USER, name, value, 4763 size, flags); 4764 } 4765 4766 struct xattr_handler ocfs2_xattr_user_handler = { 4767 .prefix = XATTR_USER_PREFIX, 4768 .list = ocfs2_xattr_user_list, 4769 .get = ocfs2_xattr_user_get, 4770 .set = ocfs2_xattr_user_set, 4771 }; 4772