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 #include <linux/security.h> 39 40 #define MLOG_MASK_PREFIX ML_XATTR 41 #include <cluster/masklog.h> 42 43 #include "ocfs2.h" 44 #include "alloc.h" 45 #include "blockcheck.h" 46 #include "dlmglue.h" 47 #include "file.h" 48 #include "symlink.h" 49 #include "sysfile.h" 50 #include "inode.h" 51 #include "journal.h" 52 #include "ocfs2_fs.h" 53 #include "suballoc.h" 54 #include "uptodate.h" 55 #include "buffer_head_io.h" 56 #include "super.h" 57 #include "xattr.h" 58 #include "refcounttree.h" 59 #include "acl.h" 60 61 struct ocfs2_xattr_def_value_root { 62 struct ocfs2_xattr_value_root xv; 63 struct ocfs2_extent_rec er; 64 }; 65 66 struct ocfs2_xattr_bucket { 67 /* The inode these xattrs are associated with */ 68 struct inode *bu_inode; 69 70 /* The actual buffers that make up the bucket */ 71 struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET]; 72 73 /* How many blocks make up one bucket for this filesystem */ 74 int bu_blocks; 75 }; 76 77 struct ocfs2_xattr_set_ctxt { 78 handle_t *handle; 79 struct ocfs2_alloc_context *meta_ac; 80 struct ocfs2_alloc_context *data_ac; 81 struct ocfs2_cached_dealloc_ctxt dealloc; 82 }; 83 84 #define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root)) 85 #define OCFS2_XATTR_INLINE_SIZE 80 86 #define OCFS2_XATTR_HEADER_GAP 4 87 #define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \ 88 - sizeof(struct ocfs2_xattr_header) \ 89 - OCFS2_XATTR_HEADER_GAP) 90 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \ 91 - sizeof(struct ocfs2_xattr_block) \ 92 - sizeof(struct ocfs2_xattr_header) \ 93 - OCFS2_XATTR_HEADER_GAP) 94 95 static struct ocfs2_xattr_def_value_root def_xv = { 96 .xv.xr_list.l_count = cpu_to_le16(1), 97 }; 98 99 struct xattr_handler *ocfs2_xattr_handlers[] = { 100 &ocfs2_xattr_user_handler, 101 &ocfs2_xattr_acl_access_handler, 102 &ocfs2_xattr_acl_default_handler, 103 &ocfs2_xattr_trusted_handler, 104 &ocfs2_xattr_security_handler, 105 NULL 106 }; 107 108 static struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = { 109 [OCFS2_XATTR_INDEX_USER] = &ocfs2_xattr_user_handler, 110 [OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS] 111 = &ocfs2_xattr_acl_access_handler, 112 [OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT] 113 = &ocfs2_xattr_acl_default_handler, 114 [OCFS2_XATTR_INDEX_TRUSTED] = &ocfs2_xattr_trusted_handler, 115 [OCFS2_XATTR_INDEX_SECURITY] = &ocfs2_xattr_security_handler, 116 }; 117 118 struct ocfs2_xattr_info { 119 int xi_name_index; 120 const char *xi_name; 121 int xi_name_len; 122 const void *xi_value; 123 size_t xi_value_len; 124 }; 125 126 struct ocfs2_xattr_search { 127 struct buffer_head *inode_bh; 128 /* 129 * xattr_bh point to the block buffer head which has extended attribute 130 * when extended attribute in inode, xattr_bh is equal to inode_bh. 131 */ 132 struct buffer_head *xattr_bh; 133 struct ocfs2_xattr_header *header; 134 struct ocfs2_xattr_bucket *bucket; 135 void *base; 136 void *end; 137 struct ocfs2_xattr_entry *here; 138 int not_found; 139 }; 140 141 /* Operations on struct ocfs2_xa_entry */ 142 struct ocfs2_xa_loc; 143 struct ocfs2_xa_loc_operations { 144 /* 145 * Journal functions 146 */ 147 int (*xlo_journal_access)(handle_t *handle, struct ocfs2_xa_loc *loc, 148 int type); 149 void (*xlo_journal_dirty)(handle_t *handle, struct ocfs2_xa_loc *loc); 150 151 /* 152 * Return a pointer to the appropriate buffer in loc->xl_storage 153 * at the given offset from loc->xl_header. 154 */ 155 void *(*xlo_offset_pointer)(struct ocfs2_xa_loc *loc, int offset); 156 157 /* Can we reuse the existing entry for the new value? */ 158 int (*xlo_can_reuse)(struct ocfs2_xa_loc *loc, 159 struct ocfs2_xattr_info *xi); 160 161 /* How much space is needed for the new value? */ 162 int (*xlo_check_space)(struct ocfs2_xa_loc *loc, 163 struct ocfs2_xattr_info *xi); 164 165 /* 166 * Return the offset of the first name+value pair. This is 167 * the start of our downward-filling free space. 168 */ 169 int (*xlo_get_free_start)(struct ocfs2_xa_loc *loc); 170 171 /* 172 * Remove the name+value at this location. Do whatever is 173 * appropriate with the remaining name+value pairs. 174 */ 175 void (*xlo_wipe_namevalue)(struct ocfs2_xa_loc *loc); 176 177 /* Fill xl_entry with a new entry */ 178 void (*xlo_add_entry)(struct ocfs2_xa_loc *loc, u32 name_hash); 179 180 /* Add name+value storage to an entry */ 181 void (*xlo_add_namevalue)(struct ocfs2_xa_loc *loc, int size); 182 183 /* 184 * Initialize the value buf's access and bh fields for this entry. 185 * ocfs2_xa_fill_value_buf() will handle the xv pointer. 186 */ 187 void (*xlo_fill_value_buf)(struct ocfs2_xa_loc *loc, 188 struct ocfs2_xattr_value_buf *vb); 189 }; 190 191 /* 192 * Describes an xattr entry location. This is a memory structure 193 * tracking the on-disk structure. 194 */ 195 struct ocfs2_xa_loc { 196 /* This xattr belongs to this inode */ 197 struct inode *xl_inode; 198 199 /* The ocfs2_xattr_header inside the on-disk storage. Not NULL. */ 200 struct ocfs2_xattr_header *xl_header; 201 202 /* Bytes from xl_header to the end of the storage */ 203 int xl_size; 204 205 /* 206 * The ocfs2_xattr_entry this location describes. If this is 207 * NULL, this location describes the on-disk structure where it 208 * would have been. 209 */ 210 struct ocfs2_xattr_entry *xl_entry; 211 212 /* 213 * Internal housekeeping 214 */ 215 216 /* Buffer(s) containing this entry */ 217 void *xl_storage; 218 219 /* Operations on the storage backing this location */ 220 const struct ocfs2_xa_loc_operations *xl_ops; 221 }; 222 223 /* 224 * Convenience functions to calculate how much space is needed for a 225 * given name+value pair 226 */ 227 static int namevalue_size(int name_len, uint64_t value_len) 228 { 229 if (value_len > OCFS2_XATTR_INLINE_SIZE) 230 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE; 231 else 232 return OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(value_len); 233 } 234 235 static int namevalue_size_xi(struct ocfs2_xattr_info *xi) 236 { 237 return namevalue_size(xi->xi_name_len, xi->xi_value_len); 238 } 239 240 static int namevalue_size_xe(struct ocfs2_xattr_entry *xe) 241 { 242 u64 value_len = le64_to_cpu(xe->xe_value_size); 243 244 BUG_ON((value_len > OCFS2_XATTR_INLINE_SIZE) && 245 ocfs2_xattr_is_local(xe)); 246 return namevalue_size(xe->xe_name_len, value_len); 247 } 248 249 250 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb, 251 struct ocfs2_xattr_header *xh, 252 int index, 253 int *block_off, 254 int *new_offset); 255 256 static int ocfs2_xattr_block_find(struct inode *inode, 257 int name_index, 258 const char *name, 259 struct ocfs2_xattr_search *xs); 260 static int ocfs2_xattr_index_block_find(struct inode *inode, 261 struct buffer_head *root_bh, 262 int name_index, 263 const char *name, 264 struct ocfs2_xattr_search *xs); 265 266 static int ocfs2_xattr_tree_list_index_block(struct inode *inode, 267 struct buffer_head *blk_bh, 268 char *buffer, 269 size_t buffer_size); 270 271 static int ocfs2_xattr_create_index_block(struct inode *inode, 272 struct ocfs2_xattr_search *xs, 273 struct ocfs2_xattr_set_ctxt *ctxt); 274 275 static int ocfs2_xattr_set_entry_index_block(struct inode *inode, 276 struct ocfs2_xattr_info *xi, 277 struct ocfs2_xattr_search *xs, 278 struct ocfs2_xattr_set_ctxt *ctxt); 279 280 typedef int (xattr_tree_rec_func)(struct inode *inode, 281 struct buffer_head *root_bh, 282 u64 blkno, u32 cpos, u32 len, void *para); 283 static int ocfs2_iterate_xattr_index_block(struct inode *inode, 284 struct buffer_head *root_bh, 285 xattr_tree_rec_func *rec_func, 286 void *para); 287 static int ocfs2_delete_xattr_in_bucket(struct inode *inode, 288 struct ocfs2_xattr_bucket *bucket, 289 void *para); 290 static int ocfs2_rm_xattr_cluster(struct inode *inode, 291 struct buffer_head *root_bh, 292 u64 blkno, 293 u32 cpos, 294 u32 len, 295 void *para); 296 297 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle, 298 u64 src_blk, u64 last_blk, u64 to_blk, 299 unsigned int start_bucket, 300 u32 *first_hash); 301 static int ocfs2_prepare_refcount_xattr(struct inode *inode, 302 struct ocfs2_dinode *di, 303 struct ocfs2_xattr_info *xi, 304 struct ocfs2_xattr_search *xis, 305 struct ocfs2_xattr_search *xbs, 306 struct ocfs2_refcount_tree **ref_tree, 307 int *meta_need, 308 int *credits); 309 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb, 310 struct ocfs2_xattr_bucket *bucket, 311 int offset, 312 struct ocfs2_xattr_value_root **xv, 313 struct buffer_head **bh); 314 315 static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb) 316 { 317 return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE; 318 } 319 320 static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb) 321 { 322 return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits); 323 } 324 325 #define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr) 326 #define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data) 327 #define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0)) 328 329 static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode) 330 { 331 struct ocfs2_xattr_bucket *bucket; 332 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 333 334 BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET); 335 336 bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS); 337 if (bucket) { 338 bucket->bu_inode = inode; 339 bucket->bu_blocks = blks; 340 } 341 342 return bucket; 343 } 344 345 static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket) 346 { 347 int i; 348 349 for (i = 0; i < bucket->bu_blocks; i++) { 350 brelse(bucket->bu_bhs[i]); 351 bucket->bu_bhs[i] = NULL; 352 } 353 } 354 355 static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket) 356 { 357 if (bucket) { 358 ocfs2_xattr_bucket_relse(bucket); 359 bucket->bu_inode = NULL; 360 kfree(bucket); 361 } 362 } 363 364 /* 365 * A bucket that has never been written to disk doesn't need to be 366 * read. We just need the buffer_heads. Don't call this for 367 * buckets that are already on disk. ocfs2_read_xattr_bucket() initializes 368 * them fully. 369 */ 370 static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket, 371 u64 xb_blkno) 372 { 373 int i, rc = 0; 374 375 for (i = 0; i < bucket->bu_blocks; i++) { 376 bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb, 377 xb_blkno + i); 378 if (!bucket->bu_bhs[i]) { 379 rc = -EIO; 380 mlog_errno(rc); 381 break; 382 } 383 384 if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode), 385 bucket->bu_bhs[i])) 386 ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode), 387 bucket->bu_bhs[i]); 388 } 389 390 if (rc) 391 ocfs2_xattr_bucket_relse(bucket); 392 return rc; 393 } 394 395 /* Read the xattr bucket at xb_blkno */ 396 static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket, 397 u64 xb_blkno) 398 { 399 int rc; 400 401 rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno, 402 bucket->bu_blocks, bucket->bu_bhs, 0, 403 NULL); 404 if (!rc) { 405 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); 406 rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb, 407 bucket->bu_bhs, 408 bucket->bu_blocks, 409 &bucket_xh(bucket)->xh_check); 410 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); 411 if (rc) 412 mlog_errno(rc); 413 } 414 415 if (rc) 416 ocfs2_xattr_bucket_relse(bucket); 417 return rc; 418 } 419 420 static int ocfs2_xattr_bucket_journal_access(handle_t *handle, 421 struct ocfs2_xattr_bucket *bucket, 422 int type) 423 { 424 int i, rc = 0; 425 426 for (i = 0; i < bucket->bu_blocks; i++) { 427 rc = ocfs2_journal_access(handle, 428 INODE_CACHE(bucket->bu_inode), 429 bucket->bu_bhs[i], type); 430 if (rc) { 431 mlog_errno(rc); 432 break; 433 } 434 } 435 436 return rc; 437 } 438 439 static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle, 440 struct ocfs2_xattr_bucket *bucket) 441 { 442 int i; 443 444 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); 445 ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb, 446 bucket->bu_bhs, bucket->bu_blocks, 447 &bucket_xh(bucket)->xh_check); 448 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); 449 450 for (i = 0; i < bucket->bu_blocks; i++) 451 ocfs2_journal_dirty(handle, bucket->bu_bhs[i]); 452 } 453 454 static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest, 455 struct ocfs2_xattr_bucket *src) 456 { 457 int i; 458 int blocksize = src->bu_inode->i_sb->s_blocksize; 459 460 BUG_ON(dest->bu_blocks != src->bu_blocks); 461 BUG_ON(dest->bu_inode != src->bu_inode); 462 463 for (i = 0; i < src->bu_blocks; i++) { 464 memcpy(bucket_block(dest, i), bucket_block(src, i), 465 blocksize); 466 } 467 } 468 469 static int ocfs2_validate_xattr_block(struct super_block *sb, 470 struct buffer_head *bh) 471 { 472 int rc; 473 struct ocfs2_xattr_block *xb = 474 (struct ocfs2_xattr_block *)bh->b_data; 475 476 mlog(0, "Validating xattr block %llu\n", 477 (unsigned long long)bh->b_blocknr); 478 479 BUG_ON(!buffer_uptodate(bh)); 480 481 /* 482 * If the ecc fails, we return the error but otherwise 483 * leave the filesystem running. We know any error is 484 * local to this block. 485 */ 486 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &xb->xb_check); 487 if (rc) 488 return rc; 489 490 /* 491 * Errors after here are fatal 492 */ 493 494 if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) { 495 ocfs2_error(sb, 496 "Extended attribute block #%llu has bad " 497 "signature %.*s", 498 (unsigned long long)bh->b_blocknr, 7, 499 xb->xb_signature); 500 return -EINVAL; 501 } 502 503 if (le64_to_cpu(xb->xb_blkno) != bh->b_blocknr) { 504 ocfs2_error(sb, 505 "Extended attribute block #%llu has an " 506 "invalid xb_blkno of %llu", 507 (unsigned long long)bh->b_blocknr, 508 (unsigned long long)le64_to_cpu(xb->xb_blkno)); 509 return -EINVAL; 510 } 511 512 if (le32_to_cpu(xb->xb_fs_generation) != OCFS2_SB(sb)->fs_generation) { 513 ocfs2_error(sb, 514 "Extended attribute block #%llu has an invalid " 515 "xb_fs_generation of #%u", 516 (unsigned long long)bh->b_blocknr, 517 le32_to_cpu(xb->xb_fs_generation)); 518 return -EINVAL; 519 } 520 521 return 0; 522 } 523 524 static int ocfs2_read_xattr_block(struct inode *inode, u64 xb_blkno, 525 struct buffer_head **bh) 526 { 527 int rc; 528 struct buffer_head *tmp = *bh; 529 530 rc = ocfs2_read_block(INODE_CACHE(inode), xb_blkno, &tmp, 531 ocfs2_validate_xattr_block); 532 533 /* If ocfs2_read_block() got us a new bh, pass it up. */ 534 if (!rc && !*bh) 535 *bh = tmp; 536 537 return rc; 538 } 539 540 static inline const char *ocfs2_xattr_prefix(int name_index) 541 { 542 struct xattr_handler *handler = NULL; 543 544 if (name_index > 0 && name_index < OCFS2_XATTR_MAX) 545 handler = ocfs2_xattr_handler_map[name_index]; 546 547 return handler ? handler->prefix : NULL; 548 } 549 550 static u32 ocfs2_xattr_name_hash(struct inode *inode, 551 const char *name, 552 int name_len) 553 { 554 /* Get hash value of uuid from super block */ 555 u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash; 556 int i; 557 558 /* hash extended attribute name */ 559 for (i = 0; i < name_len; i++) { 560 hash = (hash << OCFS2_HASH_SHIFT) ^ 561 (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^ 562 *name++; 563 } 564 565 return hash; 566 } 567 568 static int ocfs2_xattr_entry_real_size(int name_len, size_t value_len) 569 { 570 return namevalue_size(name_len, value_len) + 571 sizeof(struct ocfs2_xattr_entry); 572 } 573 574 static int ocfs2_xi_entry_usage(struct ocfs2_xattr_info *xi) 575 { 576 return namevalue_size_xi(xi) + 577 sizeof(struct ocfs2_xattr_entry); 578 } 579 580 static int ocfs2_xe_entry_usage(struct ocfs2_xattr_entry *xe) 581 { 582 return namevalue_size_xe(xe) + 583 sizeof(struct ocfs2_xattr_entry); 584 } 585 586 int ocfs2_calc_security_init(struct inode *dir, 587 struct ocfs2_security_xattr_info *si, 588 int *want_clusters, 589 int *xattr_credits, 590 struct ocfs2_alloc_context **xattr_ac) 591 { 592 int ret = 0; 593 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 594 int s_size = ocfs2_xattr_entry_real_size(strlen(si->name), 595 si->value_len); 596 597 /* 598 * The max space of security xattr taken inline is 599 * 256(name) + 80(value) + 16(entry) = 352 bytes, 600 * So reserve one metadata block for it is ok. 601 */ 602 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE || 603 s_size > OCFS2_XATTR_FREE_IN_IBODY) { 604 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, xattr_ac); 605 if (ret) { 606 mlog_errno(ret); 607 return ret; 608 } 609 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS; 610 } 611 612 /* reserve clusters for xattr value which will be set in B tree*/ 613 if (si->value_len > OCFS2_XATTR_INLINE_SIZE) { 614 int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb, 615 si->value_len); 616 617 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, 618 new_clusters); 619 *want_clusters += new_clusters; 620 } 621 return ret; 622 } 623 624 int ocfs2_calc_xattr_init(struct inode *dir, 625 struct buffer_head *dir_bh, 626 int mode, 627 struct ocfs2_security_xattr_info *si, 628 int *want_clusters, 629 int *xattr_credits, 630 int *want_meta) 631 { 632 int ret = 0; 633 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 634 int s_size = 0, a_size = 0, acl_len = 0, new_clusters; 635 636 if (si->enable) 637 s_size = ocfs2_xattr_entry_real_size(strlen(si->name), 638 si->value_len); 639 640 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) { 641 acl_len = ocfs2_xattr_get_nolock(dir, dir_bh, 642 OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT, 643 "", NULL, 0); 644 if (acl_len > 0) { 645 a_size = ocfs2_xattr_entry_real_size(0, acl_len); 646 if (S_ISDIR(mode)) 647 a_size <<= 1; 648 } else if (acl_len != 0 && acl_len != -ENODATA) { 649 mlog_errno(ret); 650 return ret; 651 } 652 } 653 654 if (!(s_size + a_size)) 655 return ret; 656 657 /* 658 * The max space of security xattr taken inline is 659 * 256(name) + 80(value) + 16(entry) = 352 bytes, 660 * The max space of acl xattr taken inline is 661 * 80(value) + 16(entry) * 2(if directory) = 192 bytes, 662 * when blocksize = 512, may reserve one more cluser for 663 * xattr bucket, otherwise reserve one metadata block 664 * for them is ok. 665 * If this is a new directory with inline data, 666 * we choose to reserve the entire inline area for 667 * directory contents and force an external xattr block. 668 */ 669 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE || 670 (S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) || 671 (s_size + a_size) > OCFS2_XATTR_FREE_IN_IBODY) { 672 *want_meta = *want_meta + 1; 673 *xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS; 674 } 675 676 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE && 677 (s_size + a_size) > OCFS2_XATTR_FREE_IN_BLOCK(dir)) { 678 *want_clusters += 1; 679 *xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb); 680 } 681 682 /* 683 * reserve credits and clusters for xattrs which has large value 684 * and have to be set outside 685 */ 686 if (si->enable && si->value_len > OCFS2_XATTR_INLINE_SIZE) { 687 new_clusters = ocfs2_clusters_for_bytes(dir->i_sb, 688 si->value_len); 689 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, 690 new_clusters); 691 *want_clusters += new_clusters; 692 } 693 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL && 694 acl_len > OCFS2_XATTR_INLINE_SIZE) { 695 /* for directory, it has DEFAULT and ACCESS two types of acls */ 696 new_clusters = (S_ISDIR(mode) ? 2 : 1) * 697 ocfs2_clusters_for_bytes(dir->i_sb, acl_len); 698 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, 699 new_clusters); 700 *want_clusters += new_clusters; 701 } 702 703 return ret; 704 } 705 706 static int ocfs2_xattr_extend_allocation(struct inode *inode, 707 u32 clusters_to_add, 708 struct ocfs2_xattr_value_buf *vb, 709 struct ocfs2_xattr_set_ctxt *ctxt) 710 { 711 int status = 0; 712 handle_t *handle = ctxt->handle; 713 enum ocfs2_alloc_restarted why; 714 u32 prev_clusters, logical_start = le32_to_cpu(vb->vb_xv->xr_clusters); 715 struct ocfs2_extent_tree et; 716 717 mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add); 718 719 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb); 720 721 status = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh, 722 OCFS2_JOURNAL_ACCESS_WRITE); 723 if (status < 0) { 724 mlog_errno(status); 725 goto leave; 726 } 727 728 prev_clusters = le32_to_cpu(vb->vb_xv->xr_clusters); 729 status = ocfs2_add_clusters_in_btree(handle, 730 &et, 731 &logical_start, 732 clusters_to_add, 733 0, 734 ctxt->data_ac, 735 ctxt->meta_ac, 736 &why); 737 if (status < 0) { 738 mlog_errno(status); 739 goto leave; 740 } 741 742 status = ocfs2_journal_dirty(handle, vb->vb_bh); 743 if (status < 0) { 744 mlog_errno(status); 745 goto leave; 746 } 747 748 clusters_to_add -= le32_to_cpu(vb->vb_xv->xr_clusters) - prev_clusters; 749 750 /* 751 * We should have already allocated enough space before the transaction, 752 * so no need to restart. 753 */ 754 BUG_ON(why != RESTART_NONE || clusters_to_add); 755 756 leave: 757 758 return status; 759 } 760 761 static int __ocfs2_remove_xattr_range(struct inode *inode, 762 struct ocfs2_xattr_value_buf *vb, 763 u32 cpos, u32 phys_cpos, u32 len, 764 unsigned int ext_flags, 765 struct ocfs2_xattr_set_ctxt *ctxt) 766 { 767 int ret; 768 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); 769 handle_t *handle = ctxt->handle; 770 struct ocfs2_extent_tree et; 771 772 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb); 773 774 ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh, 775 OCFS2_JOURNAL_ACCESS_WRITE); 776 if (ret) { 777 mlog_errno(ret); 778 goto out; 779 } 780 781 ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac, 782 &ctxt->dealloc); 783 if (ret) { 784 mlog_errno(ret); 785 goto out; 786 } 787 788 le32_add_cpu(&vb->vb_xv->xr_clusters, -len); 789 790 ret = ocfs2_journal_dirty(handle, vb->vb_bh); 791 if (ret) { 792 mlog_errno(ret); 793 goto out; 794 } 795 796 if (ext_flags & OCFS2_EXT_REFCOUNTED) 797 ret = ocfs2_decrease_refcount(inode, handle, 798 ocfs2_blocks_to_clusters(inode->i_sb, 799 phys_blkno), 800 len, ctxt->meta_ac, &ctxt->dealloc, 1); 801 else 802 ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc, 803 phys_blkno, len); 804 if (ret) 805 mlog_errno(ret); 806 807 out: 808 return ret; 809 } 810 811 static int ocfs2_xattr_shrink_size(struct inode *inode, 812 u32 old_clusters, 813 u32 new_clusters, 814 struct ocfs2_xattr_value_buf *vb, 815 struct ocfs2_xattr_set_ctxt *ctxt) 816 { 817 int ret = 0; 818 unsigned int ext_flags; 819 u32 trunc_len, cpos, phys_cpos, alloc_size; 820 u64 block; 821 822 if (old_clusters <= new_clusters) 823 return 0; 824 825 cpos = new_clusters; 826 trunc_len = old_clusters - new_clusters; 827 while (trunc_len) { 828 ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos, 829 &alloc_size, 830 &vb->vb_xv->xr_list, &ext_flags); 831 if (ret) { 832 mlog_errno(ret); 833 goto out; 834 } 835 836 if (alloc_size > trunc_len) 837 alloc_size = trunc_len; 838 839 ret = __ocfs2_remove_xattr_range(inode, vb, cpos, 840 phys_cpos, alloc_size, 841 ext_flags, ctxt); 842 if (ret) { 843 mlog_errno(ret); 844 goto out; 845 } 846 847 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); 848 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), 849 block, alloc_size); 850 cpos += alloc_size; 851 trunc_len -= alloc_size; 852 } 853 854 out: 855 return ret; 856 } 857 858 static int ocfs2_xattr_value_truncate(struct inode *inode, 859 struct ocfs2_xattr_value_buf *vb, 860 int len, 861 struct ocfs2_xattr_set_ctxt *ctxt) 862 { 863 int ret; 864 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len); 865 u32 old_clusters = le32_to_cpu(vb->vb_xv->xr_clusters); 866 867 if (new_clusters == old_clusters) 868 return 0; 869 870 if (new_clusters > old_clusters) 871 ret = ocfs2_xattr_extend_allocation(inode, 872 new_clusters - old_clusters, 873 vb, ctxt); 874 else 875 ret = ocfs2_xattr_shrink_size(inode, 876 old_clusters, new_clusters, 877 vb, ctxt); 878 879 return ret; 880 } 881 882 static int ocfs2_xattr_list_entry(char *buffer, size_t size, 883 size_t *result, const char *prefix, 884 const char *name, int name_len) 885 { 886 char *p = buffer + *result; 887 int prefix_len = strlen(prefix); 888 int total_len = prefix_len + name_len + 1; 889 890 *result += total_len; 891 892 /* we are just looking for how big our buffer needs to be */ 893 if (!size) 894 return 0; 895 896 if (*result > size) 897 return -ERANGE; 898 899 memcpy(p, prefix, prefix_len); 900 memcpy(p + prefix_len, name, name_len); 901 p[prefix_len + name_len] = '\0'; 902 903 return 0; 904 } 905 906 static int ocfs2_xattr_list_entries(struct inode *inode, 907 struct ocfs2_xattr_header *header, 908 char *buffer, size_t buffer_size) 909 { 910 size_t result = 0; 911 int i, type, ret; 912 const char *prefix, *name; 913 914 for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) { 915 struct ocfs2_xattr_entry *entry = &header->xh_entries[i]; 916 type = ocfs2_xattr_get_type(entry); 917 prefix = ocfs2_xattr_prefix(type); 918 919 if (prefix) { 920 name = (const char *)header + 921 le16_to_cpu(entry->xe_name_offset); 922 923 ret = ocfs2_xattr_list_entry(buffer, buffer_size, 924 &result, prefix, name, 925 entry->xe_name_len); 926 if (ret) 927 return ret; 928 } 929 } 930 931 return result; 932 } 933 934 int ocfs2_has_inline_xattr_value_outside(struct inode *inode, 935 struct ocfs2_dinode *di) 936 { 937 struct ocfs2_xattr_header *xh; 938 int i; 939 940 xh = (struct ocfs2_xattr_header *) 941 ((void *)di + inode->i_sb->s_blocksize - 942 le16_to_cpu(di->i_xattr_inline_size)); 943 944 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) 945 if (!ocfs2_xattr_is_local(&xh->xh_entries[i])) 946 return 1; 947 948 return 0; 949 } 950 951 static int ocfs2_xattr_ibody_list(struct inode *inode, 952 struct ocfs2_dinode *di, 953 char *buffer, 954 size_t buffer_size) 955 { 956 struct ocfs2_xattr_header *header = NULL; 957 struct ocfs2_inode_info *oi = OCFS2_I(inode); 958 int ret = 0; 959 960 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) 961 return ret; 962 963 header = (struct ocfs2_xattr_header *) 964 ((void *)di + inode->i_sb->s_blocksize - 965 le16_to_cpu(di->i_xattr_inline_size)); 966 967 ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size); 968 969 return ret; 970 } 971 972 static int ocfs2_xattr_block_list(struct inode *inode, 973 struct ocfs2_dinode *di, 974 char *buffer, 975 size_t buffer_size) 976 { 977 struct buffer_head *blk_bh = NULL; 978 struct ocfs2_xattr_block *xb; 979 int ret = 0; 980 981 if (!di->i_xattr_loc) 982 return ret; 983 984 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc), 985 &blk_bh); 986 if (ret < 0) { 987 mlog_errno(ret); 988 return ret; 989 } 990 991 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 992 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 993 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header; 994 ret = ocfs2_xattr_list_entries(inode, header, 995 buffer, buffer_size); 996 } else 997 ret = ocfs2_xattr_tree_list_index_block(inode, blk_bh, 998 buffer, buffer_size); 999 1000 brelse(blk_bh); 1001 1002 return ret; 1003 } 1004 1005 ssize_t ocfs2_listxattr(struct dentry *dentry, 1006 char *buffer, 1007 size_t size) 1008 { 1009 int ret = 0, i_ret = 0, b_ret = 0; 1010 struct buffer_head *di_bh = NULL; 1011 struct ocfs2_dinode *di = NULL; 1012 struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode); 1013 1014 if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb))) 1015 return -EOPNOTSUPP; 1016 1017 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 1018 return ret; 1019 1020 ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0); 1021 if (ret < 0) { 1022 mlog_errno(ret); 1023 return ret; 1024 } 1025 1026 di = (struct ocfs2_dinode *)di_bh->b_data; 1027 1028 down_read(&oi->ip_xattr_sem); 1029 i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size); 1030 if (i_ret < 0) 1031 b_ret = 0; 1032 else { 1033 if (buffer) { 1034 buffer += i_ret; 1035 size -= i_ret; 1036 } 1037 b_ret = ocfs2_xattr_block_list(dentry->d_inode, di, 1038 buffer, size); 1039 if (b_ret < 0) 1040 i_ret = 0; 1041 } 1042 up_read(&oi->ip_xattr_sem); 1043 ocfs2_inode_unlock(dentry->d_inode, 0); 1044 1045 brelse(di_bh); 1046 1047 return i_ret + b_ret; 1048 } 1049 1050 static int ocfs2_xattr_find_entry(int name_index, 1051 const char *name, 1052 struct ocfs2_xattr_search *xs) 1053 { 1054 struct ocfs2_xattr_entry *entry; 1055 size_t name_len; 1056 int i, cmp = 1; 1057 1058 if (name == NULL) 1059 return -EINVAL; 1060 1061 name_len = strlen(name); 1062 entry = xs->here; 1063 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) { 1064 cmp = name_index - ocfs2_xattr_get_type(entry); 1065 if (!cmp) 1066 cmp = name_len - entry->xe_name_len; 1067 if (!cmp) 1068 cmp = memcmp(name, (xs->base + 1069 le16_to_cpu(entry->xe_name_offset)), 1070 name_len); 1071 if (cmp == 0) 1072 break; 1073 entry += 1; 1074 } 1075 xs->here = entry; 1076 1077 return cmp ? -ENODATA : 0; 1078 } 1079 1080 static int ocfs2_xattr_get_value_outside(struct inode *inode, 1081 struct ocfs2_xattr_value_root *xv, 1082 void *buffer, 1083 size_t len) 1084 { 1085 u32 cpos, p_cluster, num_clusters, bpc, clusters; 1086 u64 blkno; 1087 int i, ret = 0; 1088 size_t cplen, blocksize; 1089 struct buffer_head *bh = NULL; 1090 struct ocfs2_extent_list *el; 1091 1092 el = &xv->xr_list; 1093 clusters = le32_to_cpu(xv->xr_clusters); 1094 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 1095 blocksize = inode->i_sb->s_blocksize; 1096 1097 cpos = 0; 1098 while (cpos < clusters) { 1099 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster, 1100 &num_clusters, el, NULL); 1101 if (ret) { 1102 mlog_errno(ret); 1103 goto out; 1104 } 1105 1106 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); 1107 /* Copy ocfs2_xattr_value */ 1108 for (i = 0; i < num_clusters * bpc; i++, blkno++) { 1109 ret = ocfs2_read_block(INODE_CACHE(inode), blkno, 1110 &bh, NULL); 1111 if (ret) { 1112 mlog_errno(ret); 1113 goto out; 1114 } 1115 1116 cplen = len >= blocksize ? blocksize : len; 1117 memcpy(buffer, bh->b_data, cplen); 1118 len -= cplen; 1119 buffer += cplen; 1120 1121 brelse(bh); 1122 bh = NULL; 1123 if (len == 0) 1124 break; 1125 } 1126 cpos += num_clusters; 1127 } 1128 out: 1129 return ret; 1130 } 1131 1132 static int ocfs2_xattr_ibody_get(struct inode *inode, 1133 int name_index, 1134 const char *name, 1135 void *buffer, 1136 size_t buffer_size, 1137 struct ocfs2_xattr_search *xs) 1138 { 1139 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1140 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 1141 struct ocfs2_xattr_value_root *xv; 1142 size_t size; 1143 int ret = 0; 1144 1145 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) 1146 return -ENODATA; 1147 1148 xs->end = (void *)di + inode->i_sb->s_blocksize; 1149 xs->header = (struct ocfs2_xattr_header *) 1150 (xs->end - le16_to_cpu(di->i_xattr_inline_size)); 1151 xs->base = (void *)xs->header; 1152 xs->here = xs->header->xh_entries; 1153 1154 ret = ocfs2_xattr_find_entry(name_index, name, xs); 1155 if (ret) 1156 return ret; 1157 size = le64_to_cpu(xs->here->xe_value_size); 1158 if (buffer) { 1159 if (size > buffer_size) 1160 return -ERANGE; 1161 if (ocfs2_xattr_is_local(xs->here)) { 1162 memcpy(buffer, (void *)xs->base + 1163 le16_to_cpu(xs->here->xe_name_offset) + 1164 OCFS2_XATTR_SIZE(xs->here->xe_name_len), size); 1165 } else { 1166 xv = (struct ocfs2_xattr_value_root *) 1167 (xs->base + le16_to_cpu( 1168 xs->here->xe_name_offset) + 1169 OCFS2_XATTR_SIZE(xs->here->xe_name_len)); 1170 ret = ocfs2_xattr_get_value_outside(inode, xv, 1171 buffer, size); 1172 if (ret < 0) { 1173 mlog_errno(ret); 1174 return ret; 1175 } 1176 } 1177 } 1178 1179 return size; 1180 } 1181 1182 static int ocfs2_xattr_block_get(struct inode *inode, 1183 int name_index, 1184 const char *name, 1185 void *buffer, 1186 size_t buffer_size, 1187 struct ocfs2_xattr_search *xs) 1188 { 1189 struct ocfs2_xattr_block *xb; 1190 struct ocfs2_xattr_value_root *xv; 1191 size_t size; 1192 int ret = -ENODATA, name_offset, name_len, i; 1193 int uninitialized_var(block_off); 1194 1195 xs->bucket = ocfs2_xattr_bucket_new(inode); 1196 if (!xs->bucket) { 1197 ret = -ENOMEM; 1198 mlog_errno(ret); 1199 goto cleanup; 1200 } 1201 1202 ret = ocfs2_xattr_block_find(inode, name_index, name, xs); 1203 if (ret) { 1204 mlog_errno(ret); 1205 goto cleanup; 1206 } 1207 1208 if (xs->not_found) { 1209 ret = -ENODATA; 1210 goto cleanup; 1211 } 1212 1213 xb = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data; 1214 size = le64_to_cpu(xs->here->xe_value_size); 1215 if (buffer) { 1216 ret = -ERANGE; 1217 if (size > buffer_size) 1218 goto cleanup; 1219 1220 name_offset = le16_to_cpu(xs->here->xe_name_offset); 1221 name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len); 1222 i = xs->here - xs->header->xh_entries; 1223 1224 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) { 1225 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, 1226 bucket_xh(xs->bucket), 1227 i, 1228 &block_off, 1229 &name_offset); 1230 xs->base = bucket_block(xs->bucket, block_off); 1231 } 1232 if (ocfs2_xattr_is_local(xs->here)) { 1233 memcpy(buffer, (void *)xs->base + 1234 name_offset + name_len, size); 1235 } else { 1236 xv = (struct ocfs2_xattr_value_root *) 1237 (xs->base + name_offset + name_len); 1238 ret = ocfs2_xattr_get_value_outside(inode, xv, 1239 buffer, size); 1240 if (ret < 0) { 1241 mlog_errno(ret); 1242 goto cleanup; 1243 } 1244 } 1245 } 1246 ret = size; 1247 cleanup: 1248 ocfs2_xattr_bucket_free(xs->bucket); 1249 1250 brelse(xs->xattr_bh); 1251 xs->xattr_bh = NULL; 1252 return ret; 1253 } 1254 1255 int ocfs2_xattr_get_nolock(struct inode *inode, 1256 struct buffer_head *di_bh, 1257 int name_index, 1258 const char *name, 1259 void *buffer, 1260 size_t buffer_size) 1261 { 1262 int ret; 1263 struct ocfs2_dinode *di = NULL; 1264 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1265 struct ocfs2_xattr_search xis = { 1266 .not_found = -ENODATA, 1267 }; 1268 struct ocfs2_xattr_search xbs = { 1269 .not_found = -ENODATA, 1270 }; 1271 1272 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 1273 return -EOPNOTSUPP; 1274 1275 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 1276 ret = -ENODATA; 1277 1278 xis.inode_bh = xbs.inode_bh = di_bh; 1279 di = (struct ocfs2_dinode *)di_bh->b_data; 1280 1281 down_read(&oi->ip_xattr_sem); 1282 ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer, 1283 buffer_size, &xis); 1284 if (ret == -ENODATA && di->i_xattr_loc) 1285 ret = ocfs2_xattr_block_get(inode, name_index, name, buffer, 1286 buffer_size, &xbs); 1287 up_read(&oi->ip_xattr_sem); 1288 1289 return ret; 1290 } 1291 1292 /* ocfs2_xattr_get() 1293 * 1294 * Copy an extended attribute into the buffer provided. 1295 * Buffer is NULL to compute the size of buffer required. 1296 */ 1297 static int ocfs2_xattr_get(struct inode *inode, 1298 int name_index, 1299 const char *name, 1300 void *buffer, 1301 size_t buffer_size) 1302 { 1303 int ret; 1304 struct buffer_head *di_bh = NULL; 1305 1306 ret = ocfs2_inode_lock(inode, &di_bh, 0); 1307 if (ret < 0) { 1308 mlog_errno(ret); 1309 return ret; 1310 } 1311 ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index, 1312 name, buffer, buffer_size); 1313 1314 ocfs2_inode_unlock(inode, 0); 1315 1316 brelse(di_bh); 1317 1318 return ret; 1319 } 1320 1321 static int __ocfs2_xattr_set_value_outside(struct inode *inode, 1322 handle_t *handle, 1323 struct ocfs2_xattr_value_buf *vb, 1324 const void *value, 1325 int value_len) 1326 { 1327 int ret = 0, i, cp_len; 1328 u16 blocksize = inode->i_sb->s_blocksize; 1329 u32 p_cluster, num_clusters; 1330 u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 1331 u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len); 1332 u64 blkno; 1333 struct buffer_head *bh = NULL; 1334 unsigned int ext_flags; 1335 struct ocfs2_xattr_value_root *xv = vb->vb_xv; 1336 1337 BUG_ON(clusters > le32_to_cpu(xv->xr_clusters)); 1338 1339 while (cpos < clusters) { 1340 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster, 1341 &num_clusters, &xv->xr_list, 1342 &ext_flags); 1343 if (ret) { 1344 mlog_errno(ret); 1345 goto out; 1346 } 1347 1348 BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED); 1349 1350 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); 1351 1352 for (i = 0; i < num_clusters * bpc; i++, blkno++) { 1353 ret = ocfs2_read_block(INODE_CACHE(inode), blkno, 1354 &bh, NULL); 1355 if (ret) { 1356 mlog_errno(ret); 1357 goto out; 1358 } 1359 1360 ret = ocfs2_journal_access(handle, 1361 INODE_CACHE(inode), 1362 bh, 1363 OCFS2_JOURNAL_ACCESS_WRITE); 1364 if (ret < 0) { 1365 mlog_errno(ret); 1366 goto out; 1367 } 1368 1369 cp_len = value_len > blocksize ? blocksize : value_len; 1370 memcpy(bh->b_data, value, cp_len); 1371 value_len -= cp_len; 1372 value += cp_len; 1373 if (cp_len < blocksize) 1374 memset(bh->b_data + cp_len, 0, 1375 blocksize - cp_len); 1376 1377 ret = ocfs2_journal_dirty(handle, bh); 1378 if (ret < 0) { 1379 mlog_errno(ret); 1380 goto out; 1381 } 1382 brelse(bh); 1383 bh = NULL; 1384 1385 /* 1386 * XXX: do we need to empty all the following 1387 * blocks in this cluster? 1388 */ 1389 if (!value_len) 1390 break; 1391 } 1392 cpos += num_clusters; 1393 } 1394 out: 1395 brelse(bh); 1396 1397 return ret; 1398 } 1399 1400 static int ocfs2_xa_check_space_helper(int needed_space, int free_start, 1401 int num_entries) 1402 { 1403 int free_space; 1404 1405 if (!needed_space) 1406 return 0; 1407 1408 free_space = free_start - 1409 sizeof(struct ocfs2_xattr_header) - 1410 (num_entries * sizeof(struct ocfs2_xattr_entry)) - 1411 OCFS2_XATTR_HEADER_GAP; 1412 if (free_space < 0) 1413 return -EIO; 1414 if (free_space < needed_space) 1415 return -ENOSPC; 1416 1417 return 0; 1418 } 1419 1420 static int ocfs2_xa_journal_access(handle_t *handle, struct ocfs2_xa_loc *loc, 1421 int type) 1422 { 1423 return loc->xl_ops->xlo_journal_access(handle, loc, type); 1424 } 1425 1426 static void ocfs2_xa_journal_dirty(handle_t *handle, struct ocfs2_xa_loc *loc) 1427 { 1428 loc->xl_ops->xlo_journal_dirty(handle, loc); 1429 } 1430 1431 /* Give a pointer into the storage for the given offset */ 1432 static void *ocfs2_xa_offset_pointer(struct ocfs2_xa_loc *loc, int offset) 1433 { 1434 BUG_ON(offset >= loc->xl_size); 1435 return loc->xl_ops->xlo_offset_pointer(loc, offset); 1436 } 1437 1438 /* 1439 * Wipe the name+value pair and allow the storage to reclaim it. This 1440 * must be followed by either removal of the entry or a call to 1441 * ocfs2_xa_add_namevalue(). 1442 */ 1443 static void ocfs2_xa_wipe_namevalue(struct ocfs2_xa_loc *loc) 1444 { 1445 loc->xl_ops->xlo_wipe_namevalue(loc); 1446 } 1447 1448 /* 1449 * Find lowest offset to a name+value pair. This is the start of our 1450 * downward-growing free space. 1451 */ 1452 static int ocfs2_xa_get_free_start(struct ocfs2_xa_loc *loc) 1453 { 1454 return loc->xl_ops->xlo_get_free_start(loc); 1455 } 1456 1457 /* Can we reuse loc->xl_entry for xi? */ 1458 static int ocfs2_xa_can_reuse_entry(struct ocfs2_xa_loc *loc, 1459 struct ocfs2_xattr_info *xi) 1460 { 1461 return loc->xl_ops->xlo_can_reuse(loc, xi); 1462 } 1463 1464 /* How much free space is needed to set the new value */ 1465 static int ocfs2_xa_check_space(struct ocfs2_xa_loc *loc, 1466 struct ocfs2_xattr_info *xi) 1467 { 1468 return loc->xl_ops->xlo_check_space(loc, xi); 1469 } 1470 1471 static void ocfs2_xa_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash) 1472 { 1473 loc->xl_ops->xlo_add_entry(loc, name_hash); 1474 loc->xl_entry->xe_name_hash = cpu_to_le32(name_hash); 1475 /* 1476 * We can't leave the new entry's xe_name_offset at zero or 1477 * add_namevalue() will go nuts. We set it to the size of our 1478 * storage so that it can never be less than any other entry. 1479 */ 1480 loc->xl_entry->xe_name_offset = cpu_to_le16(loc->xl_size); 1481 } 1482 1483 static void ocfs2_xa_add_namevalue(struct ocfs2_xa_loc *loc, 1484 struct ocfs2_xattr_info *xi) 1485 { 1486 int size = namevalue_size_xi(xi); 1487 int nameval_offset; 1488 char *nameval_buf; 1489 1490 loc->xl_ops->xlo_add_namevalue(loc, size); 1491 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len); 1492 loc->xl_entry->xe_name_len = xi->xi_name_len; 1493 ocfs2_xattr_set_type(loc->xl_entry, xi->xi_name_index); 1494 ocfs2_xattr_set_local(loc->xl_entry, 1495 xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE); 1496 1497 nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset); 1498 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset); 1499 memset(nameval_buf, 0, size); 1500 memcpy(nameval_buf, xi->xi_name, xi->xi_name_len); 1501 } 1502 1503 static void ocfs2_xa_fill_value_buf(struct ocfs2_xa_loc *loc, 1504 struct ocfs2_xattr_value_buf *vb) 1505 { 1506 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset); 1507 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len); 1508 1509 /* Value bufs are for value trees */ 1510 BUG_ON(ocfs2_xattr_is_local(loc->xl_entry)); 1511 BUG_ON(namevalue_size_xe(loc->xl_entry) != 1512 (name_size + OCFS2_XATTR_ROOT_SIZE)); 1513 1514 loc->xl_ops->xlo_fill_value_buf(loc, vb); 1515 vb->vb_xv = 1516 (struct ocfs2_xattr_value_root *)ocfs2_xa_offset_pointer(loc, 1517 nameval_offset + 1518 name_size); 1519 } 1520 1521 static int ocfs2_xa_block_journal_access(handle_t *handle, 1522 struct ocfs2_xa_loc *loc, int type) 1523 { 1524 struct buffer_head *bh = loc->xl_storage; 1525 ocfs2_journal_access_func access; 1526 1527 if (loc->xl_size == (bh->b_size - 1528 offsetof(struct ocfs2_xattr_block, 1529 xb_attrs.xb_header))) 1530 access = ocfs2_journal_access_xb; 1531 else 1532 access = ocfs2_journal_access_di; 1533 return access(handle, INODE_CACHE(loc->xl_inode), bh, type); 1534 } 1535 1536 static void ocfs2_xa_block_journal_dirty(handle_t *handle, 1537 struct ocfs2_xa_loc *loc) 1538 { 1539 struct buffer_head *bh = loc->xl_storage; 1540 1541 ocfs2_journal_dirty(handle, bh); 1542 } 1543 1544 static void *ocfs2_xa_block_offset_pointer(struct ocfs2_xa_loc *loc, 1545 int offset) 1546 { 1547 return (char *)loc->xl_header + offset; 1548 } 1549 1550 static int ocfs2_xa_block_can_reuse(struct ocfs2_xa_loc *loc, 1551 struct ocfs2_xattr_info *xi) 1552 { 1553 /* 1554 * Block storage is strict. If the sizes aren't exact, we will 1555 * remove the old one and reinsert the new. 1556 */ 1557 return namevalue_size_xe(loc->xl_entry) == 1558 namevalue_size_xi(xi); 1559 } 1560 1561 static int ocfs2_xa_block_get_free_start(struct ocfs2_xa_loc *loc) 1562 { 1563 struct ocfs2_xattr_header *xh = loc->xl_header; 1564 int i, count = le16_to_cpu(xh->xh_count); 1565 int offset, free_start = loc->xl_size; 1566 1567 for (i = 0; i < count; i++) { 1568 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset); 1569 if (offset < free_start) 1570 free_start = offset; 1571 } 1572 1573 return free_start; 1574 } 1575 1576 static int ocfs2_xa_block_check_space(struct ocfs2_xa_loc *loc, 1577 struct ocfs2_xattr_info *xi) 1578 { 1579 int count = le16_to_cpu(loc->xl_header->xh_count); 1580 int free_start = ocfs2_xa_get_free_start(loc); 1581 int needed_space = ocfs2_xi_entry_usage(xi); 1582 1583 /* 1584 * Block storage will reclaim the original entry before inserting 1585 * the new value, so we only need the difference. If the new 1586 * entry is smaller than the old one, we don't need anything. 1587 */ 1588 if (loc->xl_entry) { 1589 /* Don't need space if we're reusing! */ 1590 if (ocfs2_xa_can_reuse_entry(loc, xi)) 1591 needed_space = 0; 1592 else 1593 needed_space -= ocfs2_xe_entry_usage(loc->xl_entry); 1594 } 1595 if (needed_space < 0) 1596 needed_space = 0; 1597 return ocfs2_xa_check_space_helper(needed_space, free_start, count); 1598 } 1599 1600 /* 1601 * Block storage for xattrs keeps the name+value pairs compacted. When 1602 * we remove one, we have to shift any that preceded it towards the end. 1603 */ 1604 static void ocfs2_xa_block_wipe_namevalue(struct ocfs2_xa_loc *loc) 1605 { 1606 int i, offset; 1607 int namevalue_offset, first_namevalue_offset, namevalue_size; 1608 struct ocfs2_xattr_entry *entry = loc->xl_entry; 1609 struct ocfs2_xattr_header *xh = loc->xl_header; 1610 int count = le16_to_cpu(xh->xh_count); 1611 1612 namevalue_offset = le16_to_cpu(entry->xe_name_offset); 1613 namevalue_size = namevalue_size_xe(entry); 1614 first_namevalue_offset = ocfs2_xa_get_free_start(loc); 1615 1616 /* Shift the name+value pairs */ 1617 memmove((char *)xh + first_namevalue_offset + namevalue_size, 1618 (char *)xh + first_namevalue_offset, 1619 namevalue_offset - first_namevalue_offset); 1620 memset((char *)xh + first_namevalue_offset, 0, namevalue_size); 1621 1622 /* Now tell xh->xh_entries about it */ 1623 for (i = 0; i < count; i++) { 1624 offset = le16_to_cpu(xh->xh_entries[i].xe_name_offset); 1625 if (offset <= namevalue_offset) 1626 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, 1627 namevalue_size); 1628 } 1629 1630 /* 1631 * Note that we don't update xh_free_start or xh_name_value_len 1632 * because they're not used in block-stored xattrs. 1633 */ 1634 } 1635 1636 static void ocfs2_xa_block_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash) 1637 { 1638 int count = le16_to_cpu(loc->xl_header->xh_count); 1639 loc->xl_entry = &(loc->xl_header->xh_entries[count]); 1640 le16_add_cpu(&loc->xl_header->xh_count, 1); 1641 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry)); 1642 } 1643 1644 static void ocfs2_xa_block_add_namevalue(struct ocfs2_xa_loc *loc, int size) 1645 { 1646 int free_start = ocfs2_xa_get_free_start(loc); 1647 1648 loc->xl_entry->xe_name_offset = cpu_to_le16(free_start - size); 1649 } 1650 1651 static void ocfs2_xa_block_fill_value_buf(struct ocfs2_xa_loc *loc, 1652 struct ocfs2_xattr_value_buf *vb) 1653 { 1654 struct buffer_head *bh = loc->xl_storage; 1655 1656 if (loc->xl_size == (bh->b_size - 1657 offsetof(struct ocfs2_xattr_block, 1658 xb_attrs.xb_header))) 1659 vb->vb_access = ocfs2_journal_access_xb; 1660 else 1661 vb->vb_access = ocfs2_journal_access_di; 1662 vb->vb_bh = bh; 1663 } 1664 1665 /* 1666 * Operations for xattrs stored in blocks. This includes inline inode 1667 * storage and unindexed ocfs2_xattr_blocks. 1668 */ 1669 static const struct ocfs2_xa_loc_operations ocfs2_xa_block_loc_ops = { 1670 .xlo_journal_access = ocfs2_xa_block_journal_access, 1671 .xlo_journal_dirty = ocfs2_xa_block_journal_dirty, 1672 .xlo_offset_pointer = ocfs2_xa_block_offset_pointer, 1673 .xlo_check_space = ocfs2_xa_block_check_space, 1674 .xlo_can_reuse = ocfs2_xa_block_can_reuse, 1675 .xlo_get_free_start = ocfs2_xa_block_get_free_start, 1676 .xlo_wipe_namevalue = ocfs2_xa_block_wipe_namevalue, 1677 .xlo_add_entry = ocfs2_xa_block_add_entry, 1678 .xlo_add_namevalue = ocfs2_xa_block_add_namevalue, 1679 .xlo_fill_value_buf = ocfs2_xa_block_fill_value_buf, 1680 }; 1681 1682 static int ocfs2_xa_bucket_journal_access(handle_t *handle, 1683 struct ocfs2_xa_loc *loc, int type) 1684 { 1685 struct ocfs2_xattr_bucket *bucket = loc->xl_storage; 1686 1687 return ocfs2_xattr_bucket_journal_access(handle, bucket, type); 1688 } 1689 1690 static void ocfs2_xa_bucket_journal_dirty(handle_t *handle, 1691 struct ocfs2_xa_loc *loc) 1692 { 1693 struct ocfs2_xattr_bucket *bucket = loc->xl_storage; 1694 1695 ocfs2_xattr_bucket_journal_dirty(handle, bucket); 1696 } 1697 1698 static void *ocfs2_xa_bucket_offset_pointer(struct ocfs2_xa_loc *loc, 1699 int offset) 1700 { 1701 struct ocfs2_xattr_bucket *bucket = loc->xl_storage; 1702 int block, block_offset; 1703 1704 /* The header is at the front of the bucket */ 1705 block = offset >> loc->xl_inode->i_sb->s_blocksize_bits; 1706 block_offset = offset % loc->xl_inode->i_sb->s_blocksize; 1707 1708 return bucket_block(bucket, block) + block_offset; 1709 } 1710 1711 static int ocfs2_xa_bucket_can_reuse(struct ocfs2_xa_loc *loc, 1712 struct ocfs2_xattr_info *xi) 1713 { 1714 return namevalue_size_xe(loc->xl_entry) >= 1715 namevalue_size_xi(xi); 1716 } 1717 1718 static int ocfs2_xa_bucket_get_free_start(struct ocfs2_xa_loc *loc) 1719 { 1720 struct ocfs2_xattr_bucket *bucket = loc->xl_storage; 1721 return le16_to_cpu(bucket_xh(bucket)->xh_free_start); 1722 } 1723 1724 static int ocfs2_bucket_align_free_start(struct super_block *sb, 1725 int free_start, int size) 1726 { 1727 /* 1728 * We need to make sure that the name+value pair fits within 1729 * one block. 1730 */ 1731 if (((free_start - size) >> sb->s_blocksize_bits) != 1732 ((free_start - 1) >> sb->s_blocksize_bits)) 1733 free_start -= free_start % sb->s_blocksize; 1734 1735 return free_start; 1736 } 1737 1738 static int ocfs2_xa_bucket_check_space(struct ocfs2_xa_loc *loc, 1739 struct ocfs2_xattr_info *xi) 1740 { 1741 int rc; 1742 int count = le16_to_cpu(loc->xl_header->xh_count); 1743 int free_start = ocfs2_xa_get_free_start(loc); 1744 int needed_space = ocfs2_xi_entry_usage(xi); 1745 int size = namevalue_size_xi(xi); 1746 struct super_block *sb = loc->xl_inode->i_sb; 1747 1748 /* 1749 * Bucket storage does not reclaim name+value pairs it cannot 1750 * reuse. They live as holes until the bucket fills, and then 1751 * the bucket is defragmented. However, the bucket can reclaim 1752 * the ocfs2_xattr_entry. 1753 */ 1754 if (loc->xl_entry) { 1755 /* Don't need space if we're reusing! */ 1756 if (ocfs2_xa_can_reuse_entry(loc, xi)) 1757 needed_space = 0; 1758 else 1759 needed_space -= sizeof(struct ocfs2_xattr_entry); 1760 } 1761 BUG_ON(needed_space < 0); 1762 1763 if (free_start < size) { 1764 if (needed_space) 1765 return -ENOSPC; 1766 } else { 1767 /* 1768 * First we check if it would fit in the first place. 1769 * Below, we align the free start to a block. This may 1770 * slide us below the minimum gap. By checking unaligned 1771 * first, we avoid that error. 1772 */ 1773 rc = ocfs2_xa_check_space_helper(needed_space, free_start, 1774 count); 1775 if (rc) 1776 return rc; 1777 free_start = ocfs2_bucket_align_free_start(sb, free_start, 1778 size); 1779 } 1780 return ocfs2_xa_check_space_helper(needed_space, free_start, count); 1781 } 1782 1783 static void ocfs2_xa_bucket_wipe_namevalue(struct ocfs2_xa_loc *loc) 1784 { 1785 le16_add_cpu(&loc->xl_header->xh_name_value_len, 1786 -namevalue_size_xe(loc->xl_entry)); 1787 } 1788 1789 static void ocfs2_xa_bucket_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash) 1790 { 1791 struct ocfs2_xattr_header *xh = loc->xl_header; 1792 int count = le16_to_cpu(xh->xh_count); 1793 int low = 0, high = count - 1, tmp; 1794 struct ocfs2_xattr_entry *tmp_xe; 1795 1796 /* 1797 * We keep buckets sorted by name_hash, so we need to find 1798 * our insert place. 1799 */ 1800 while (low <= high && count) { 1801 tmp = (low + high) / 2; 1802 tmp_xe = &xh->xh_entries[tmp]; 1803 1804 if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash)) 1805 low = tmp + 1; 1806 else if (name_hash < le32_to_cpu(tmp_xe->xe_name_hash)) 1807 high = tmp - 1; 1808 else { 1809 low = tmp; 1810 break; 1811 } 1812 } 1813 1814 if (low != count) 1815 memmove(&xh->xh_entries[low + 1], 1816 &xh->xh_entries[low], 1817 ((count - low) * sizeof(struct ocfs2_xattr_entry))); 1818 1819 le16_add_cpu(&xh->xh_count, 1); 1820 loc->xl_entry = &xh->xh_entries[low]; 1821 memset(loc->xl_entry, 0, sizeof(struct ocfs2_xattr_entry)); 1822 } 1823 1824 static void ocfs2_xa_bucket_add_namevalue(struct ocfs2_xa_loc *loc, int size) 1825 { 1826 int free_start = ocfs2_xa_get_free_start(loc); 1827 struct ocfs2_xattr_header *xh = loc->xl_header; 1828 struct super_block *sb = loc->xl_inode->i_sb; 1829 int nameval_offset; 1830 1831 free_start = ocfs2_bucket_align_free_start(sb, free_start, size); 1832 nameval_offset = free_start - size; 1833 loc->xl_entry->xe_name_offset = cpu_to_le16(nameval_offset); 1834 xh->xh_free_start = cpu_to_le16(nameval_offset); 1835 le16_add_cpu(&xh->xh_name_value_len, size); 1836 1837 } 1838 1839 static void ocfs2_xa_bucket_fill_value_buf(struct ocfs2_xa_loc *loc, 1840 struct ocfs2_xattr_value_buf *vb) 1841 { 1842 struct ocfs2_xattr_bucket *bucket = loc->xl_storage; 1843 struct super_block *sb = loc->xl_inode->i_sb; 1844 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset); 1845 int size = namevalue_size_xe(loc->xl_entry); 1846 int block_offset = nameval_offset >> sb->s_blocksize_bits; 1847 1848 /* Values are not allowed to straddle block boundaries */ 1849 BUG_ON(block_offset != 1850 ((nameval_offset + size - 1) >> sb->s_blocksize_bits)); 1851 /* We expect the bucket to be filled in */ 1852 BUG_ON(!bucket->bu_bhs[block_offset]); 1853 1854 vb->vb_access = ocfs2_journal_access; 1855 vb->vb_bh = bucket->bu_bhs[block_offset]; 1856 } 1857 1858 /* Operations for xattrs stored in buckets. */ 1859 static const struct ocfs2_xa_loc_operations ocfs2_xa_bucket_loc_ops = { 1860 .xlo_journal_access = ocfs2_xa_bucket_journal_access, 1861 .xlo_journal_dirty = ocfs2_xa_bucket_journal_dirty, 1862 .xlo_offset_pointer = ocfs2_xa_bucket_offset_pointer, 1863 .xlo_check_space = ocfs2_xa_bucket_check_space, 1864 .xlo_can_reuse = ocfs2_xa_bucket_can_reuse, 1865 .xlo_get_free_start = ocfs2_xa_bucket_get_free_start, 1866 .xlo_wipe_namevalue = ocfs2_xa_bucket_wipe_namevalue, 1867 .xlo_add_entry = ocfs2_xa_bucket_add_entry, 1868 .xlo_add_namevalue = ocfs2_xa_bucket_add_namevalue, 1869 .xlo_fill_value_buf = ocfs2_xa_bucket_fill_value_buf, 1870 }; 1871 1872 static unsigned int ocfs2_xa_value_clusters(struct ocfs2_xa_loc *loc) 1873 { 1874 struct ocfs2_xattr_value_buf vb; 1875 1876 if (ocfs2_xattr_is_local(loc->xl_entry)) 1877 return 0; 1878 1879 ocfs2_xa_fill_value_buf(loc, &vb); 1880 return le32_to_cpu(vb.vb_xv->xr_clusters); 1881 } 1882 1883 static int ocfs2_xa_value_truncate(struct ocfs2_xa_loc *loc, u64 bytes, 1884 struct ocfs2_xattr_set_ctxt *ctxt) 1885 { 1886 int trunc_rc, access_rc; 1887 struct ocfs2_xattr_value_buf vb; 1888 1889 ocfs2_xa_fill_value_buf(loc, &vb); 1890 trunc_rc = ocfs2_xattr_value_truncate(loc->xl_inode, &vb, bytes, 1891 ctxt); 1892 1893 /* 1894 * The caller of ocfs2_xa_value_truncate() has already called 1895 * ocfs2_xa_journal_access on the loc. However, The truncate code 1896 * calls ocfs2_extend_trans(). This may commit the previous 1897 * transaction and open a new one. If this is a bucket, truncate 1898 * could leave only vb->vb_bh set up for journaling. Meanwhile, 1899 * the caller is expecting to dirty the entire bucket. So we must 1900 * reset the journal work. We do this even if truncate has failed, 1901 * as it could have failed after committing the extend. 1902 */ 1903 access_rc = ocfs2_xa_journal_access(ctxt->handle, loc, 1904 OCFS2_JOURNAL_ACCESS_WRITE); 1905 1906 /* Errors in truncate take precedence */ 1907 return trunc_rc ? trunc_rc : access_rc; 1908 } 1909 1910 static void ocfs2_xa_remove_entry(struct ocfs2_xa_loc *loc) 1911 { 1912 int index, count; 1913 struct ocfs2_xattr_header *xh = loc->xl_header; 1914 struct ocfs2_xattr_entry *entry = loc->xl_entry; 1915 1916 ocfs2_xa_wipe_namevalue(loc); 1917 loc->xl_entry = NULL; 1918 1919 le16_add_cpu(&xh->xh_count, -1); 1920 count = le16_to_cpu(xh->xh_count); 1921 1922 /* 1923 * Only zero out the entry if there are more remaining. This is 1924 * important for an empty bucket, as it keeps track of the 1925 * bucket's hash value. It doesn't hurt empty block storage. 1926 */ 1927 if (count) { 1928 index = ((char *)entry - (char *)&xh->xh_entries) / 1929 sizeof(struct ocfs2_xattr_entry); 1930 memmove(&xh->xh_entries[index], &xh->xh_entries[index + 1], 1931 (count - index) * sizeof(struct ocfs2_xattr_entry)); 1932 memset(&xh->xh_entries[count], 0, 1933 sizeof(struct ocfs2_xattr_entry)); 1934 } 1935 } 1936 1937 /* 1938 * If we have a problem adjusting the size of an external value during 1939 * ocfs2_xa_prepare_entry() or ocfs2_xa_remove(), we may have an xattr 1940 * in an intermediate state. For example, the value may be partially 1941 * truncated. 1942 * 1943 * If the value tree hasn't changed, the extend/truncate went nowhere. 1944 * We have nothing to do. The caller can treat it as a straight error. 1945 * 1946 * If the value tree got partially truncated, we now have a corrupted 1947 * extended attribute. We're going to wipe its entry and leak the 1948 * clusters. Better to leak some storage than leave a corrupt entry. 1949 * 1950 * If the value tree grew, it obviously didn't grow enough for the 1951 * new entry. We're not going to try and reclaim those clusters either. 1952 * If there was already an external value there (orig_clusters != 0), 1953 * the new clusters are attached safely and we can just leave the old 1954 * value in place. If there was no external value there, we remove 1955 * the entry. 1956 * 1957 * This way, the xattr block we store in the journal will be consistent. 1958 * If the size change broke because of the journal, no changes will hit 1959 * disk anyway. 1960 */ 1961 static void ocfs2_xa_cleanup_value_truncate(struct ocfs2_xa_loc *loc, 1962 const char *what, 1963 unsigned int orig_clusters) 1964 { 1965 unsigned int new_clusters = ocfs2_xa_value_clusters(loc); 1966 char *nameval_buf = ocfs2_xa_offset_pointer(loc, 1967 le16_to_cpu(loc->xl_entry->xe_name_offset)); 1968 1969 if (new_clusters < orig_clusters) { 1970 mlog(ML_ERROR, 1971 "Partial truncate while %s xattr %.*s. Leaking " 1972 "%u clusters and removing the entry\n", 1973 what, loc->xl_entry->xe_name_len, nameval_buf, 1974 orig_clusters - new_clusters); 1975 ocfs2_xa_remove_entry(loc); 1976 } else if (!orig_clusters) { 1977 mlog(ML_ERROR, 1978 "Unable to allocate an external value for xattr " 1979 "%.*s safely. Leaking %u clusters and removing the " 1980 "entry\n", 1981 loc->xl_entry->xe_name_len, nameval_buf, 1982 new_clusters - orig_clusters); 1983 ocfs2_xa_remove_entry(loc); 1984 } else if (new_clusters > orig_clusters) 1985 mlog(ML_ERROR, 1986 "Unable to grow xattr %.*s safely. %u new clusters " 1987 "have been added, but the value will not be " 1988 "modified\n", 1989 loc->xl_entry->xe_name_len, nameval_buf, 1990 new_clusters - orig_clusters); 1991 } 1992 1993 static int ocfs2_xa_remove(struct ocfs2_xa_loc *loc, 1994 struct ocfs2_xattr_set_ctxt *ctxt) 1995 { 1996 int rc = 0; 1997 unsigned int orig_clusters; 1998 1999 if (!ocfs2_xattr_is_local(loc->xl_entry)) { 2000 orig_clusters = ocfs2_xa_value_clusters(loc); 2001 rc = ocfs2_xa_value_truncate(loc, 0, ctxt); 2002 if (rc) { 2003 mlog_errno(rc); 2004 /* 2005 * Since this is remove, we can return 0 if 2006 * ocfs2_xa_cleanup_value_truncate() is going to 2007 * wipe the entry anyway. So we check the 2008 * cluster count as well. 2009 */ 2010 if (orig_clusters != ocfs2_xa_value_clusters(loc)) 2011 rc = 0; 2012 ocfs2_xa_cleanup_value_truncate(loc, "removing", 2013 orig_clusters); 2014 if (rc) 2015 goto out; 2016 } 2017 } 2018 2019 ocfs2_xa_remove_entry(loc); 2020 2021 out: 2022 return rc; 2023 } 2024 2025 static void ocfs2_xa_install_value_root(struct ocfs2_xa_loc *loc) 2026 { 2027 int name_size = OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len); 2028 char *nameval_buf; 2029 2030 nameval_buf = ocfs2_xa_offset_pointer(loc, 2031 le16_to_cpu(loc->xl_entry->xe_name_offset)); 2032 memcpy(nameval_buf + name_size, &def_xv, OCFS2_XATTR_ROOT_SIZE); 2033 } 2034 2035 /* 2036 * Take an existing entry and make it ready for the new value. This 2037 * won't allocate space, but it may free space. It should be ready for 2038 * ocfs2_xa_prepare_entry() to finish the work. 2039 */ 2040 static int ocfs2_xa_reuse_entry(struct ocfs2_xa_loc *loc, 2041 struct ocfs2_xattr_info *xi, 2042 struct ocfs2_xattr_set_ctxt *ctxt) 2043 { 2044 int rc = 0; 2045 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len); 2046 unsigned int orig_clusters; 2047 char *nameval_buf; 2048 int xe_local = ocfs2_xattr_is_local(loc->xl_entry); 2049 int xi_local = xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE; 2050 2051 BUG_ON(OCFS2_XATTR_SIZE(loc->xl_entry->xe_name_len) != 2052 name_size); 2053 2054 nameval_buf = ocfs2_xa_offset_pointer(loc, 2055 le16_to_cpu(loc->xl_entry->xe_name_offset)); 2056 if (xe_local) { 2057 memset(nameval_buf + name_size, 0, 2058 namevalue_size_xe(loc->xl_entry) - name_size); 2059 if (!xi_local) 2060 ocfs2_xa_install_value_root(loc); 2061 } else { 2062 orig_clusters = ocfs2_xa_value_clusters(loc); 2063 if (xi_local) { 2064 rc = ocfs2_xa_value_truncate(loc, 0, ctxt); 2065 if (rc < 0) 2066 mlog_errno(rc); 2067 else 2068 memset(nameval_buf + name_size, 0, 2069 namevalue_size_xe(loc->xl_entry) - 2070 name_size); 2071 } else if (le64_to_cpu(loc->xl_entry->xe_value_size) > 2072 xi->xi_value_len) { 2073 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len, 2074 ctxt); 2075 if (rc < 0) 2076 mlog_errno(rc); 2077 } 2078 2079 if (rc) { 2080 ocfs2_xa_cleanup_value_truncate(loc, "reusing", 2081 orig_clusters); 2082 goto out; 2083 } 2084 } 2085 2086 loc->xl_entry->xe_value_size = cpu_to_le64(xi->xi_value_len); 2087 ocfs2_xattr_set_local(loc->xl_entry, xi_local); 2088 2089 out: 2090 return rc; 2091 } 2092 2093 /* 2094 * Prepares loc->xl_entry to receive the new xattr. This includes 2095 * properly setting up the name+value pair region. If loc->xl_entry 2096 * already exists, it will take care of modifying it appropriately. 2097 * 2098 * Note that this modifies the data. You did journal_access already, 2099 * right? 2100 */ 2101 static int ocfs2_xa_prepare_entry(struct ocfs2_xa_loc *loc, 2102 struct ocfs2_xattr_info *xi, 2103 u32 name_hash, 2104 struct ocfs2_xattr_set_ctxt *ctxt) 2105 { 2106 int rc = 0; 2107 unsigned int orig_clusters; 2108 __le64 orig_value_size = 0; 2109 2110 rc = ocfs2_xa_check_space(loc, xi); 2111 if (rc) 2112 goto out; 2113 2114 if (loc->xl_entry) { 2115 if (ocfs2_xa_can_reuse_entry(loc, xi)) { 2116 orig_value_size = loc->xl_entry->xe_value_size; 2117 rc = ocfs2_xa_reuse_entry(loc, xi, ctxt); 2118 if (rc) 2119 goto out; 2120 goto alloc_value; 2121 } 2122 2123 if (!ocfs2_xattr_is_local(loc->xl_entry)) { 2124 orig_clusters = ocfs2_xa_value_clusters(loc); 2125 rc = ocfs2_xa_value_truncate(loc, 0, ctxt); 2126 if (rc) { 2127 mlog_errno(rc); 2128 ocfs2_xa_cleanup_value_truncate(loc, 2129 "overwriting", 2130 orig_clusters); 2131 goto out; 2132 } 2133 } 2134 ocfs2_xa_wipe_namevalue(loc); 2135 } else 2136 ocfs2_xa_add_entry(loc, name_hash); 2137 2138 /* 2139 * If we get here, we have a blank entry. Fill it. We grow our 2140 * name+value pair back from the end. 2141 */ 2142 ocfs2_xa_add_namevalue(loc, xi); 2143 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) 2144 ocfs2_xa_install_value_root(loc); 2145 2146 alloc_value: 2147 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) { 2148 orig_clusters = ocfs2_xa_value_clusters(loc); 2149 rc = ocfs2_xa_value_truncate(loc, xi->xi_value_len, ctxt); 2150 if (rc < 0) { 2151 /* 2152 * If we tried to grow an existing external value, 2153 * ocfs2_xa_cleanuP-value_truncate() is going to 2154 * let it stand. We have to restore its original 2155 * value size. 2156 */ 2157 loc->xl_entry->xe_value_size = orig_value_size; 2158 ocfs2_xa_cleanup_value_truncate(loc, "growing", 2159 orig_clusters); 2160 mlog_errno(rc); 2161 } 2162 } 2163 2164 out: 2165 return rc; 2166 } 2167 2168 /* 2169 * Store the value portion of the name+value pair. This will skip 2170 * values that are stored externally. Their tree roots were set up 2171 * by ocfs2_xa_prepare_entry(). 2172 */ 2173 static int ocfs2_xa_store_value(struct ocfs2_xa_loc *loc, 2174 struct ocfs2_xattr_info *xi, 2175 struct ocfs2_xattr_set_ctxt *ctxt) 2176 { 2177 int rc = 0; 2178 int nameval_offset = le16_to_cpu(loc->xl_entry->xe_name_offset); 2179 int name_size = OCFS2_XATTR_SIZE(xi->xi_name_len); 2180 char *nameval_buf; 2181 struct ocfs2_xattr_value_buf vb; 2182 2183 nameval_buf = ocfs2_xa_offset_pointer(loc, nameval_offset); 2184 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) { 2185 ocfs2_xa_fill_value_buf(loc, &vb); 2186 rc = __ocfs2_xattr_set_value_outside(loc->xl_inode, 2187 ctxt->handle, &vb, 2188 xi->xi_value, 2189 xi->xi_value_len); 2190 } else 2191 memcpy(nameval_buf + name_size, xi->xi_value, xi->xi_value_len); 2192 2193 return rc; 2194 } 2195 2196 static int ocfs2_xa_set(struct ocfs2_xa_loc *loc, 2197 struct ocfs2_xattr_info *xi, 2198 struct ocfs2_xattr_set_ctxt *ctxt) 2199 { 2200 int ret; 2201 u32 name_hash = ocfs2_xattr_name_hash(loc->xl_inode, xi->xi_name, 2202 xi->xi_name_len); 2203 2204 ret = ocfs2_xa_journal_access(ctxt->handle, loc, 2205 OCFS2_JOURNAL_ACCESS_WRITE); 2206 if (ret) { 2207 mlog_errno(ret); 2208 goto out; 2209 } 2210 2211 /* 2212 * From here on out, everything is going to modify the buffer a 2213 * little. Errors are going to leave the xattr header in a 2214 * sane state. Thus, even with errors we dirty the sucker. 2215 */ 2216 2217 /* Don't worry, we are never called with !xi_value and !xl_entry */ 2218 if (!xi->xi_value) { 2219 ret = ocfs2_xa_remove(loc, ctxt); 2220 goto out_dirty; 2221 } 2222 2223 ret = ocfs2_xa_prepare_entry(loc, xi, name_hash, ctxt); 2224 if (ret) { 2225 if (ret != -ENOSPC) 2226 mlog_errno(ret); 2227 goto out_dirty; 2228 } 2229 2230 ret = ocfs2_xa_store_value(loc, xi, ctxt); 2231 if (ret) 2232 mlog_errno(ret); 2233 2234 out_dirty: 2235 ocfs2_xa_journal_dirty(ctxt->handle, loc); 2236 2237 out: 2238 return ret; 2239 } 2240 2241 static void ocfs2_init_dinode_xa_loc(struct ocfs2_xa_loc *loc, 2242 struct inode *inode, 2243 struct buffer_head *bh, 2244 struct ocfs2_xattr_entry *entry) 2245 { 2246 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 2247 2248 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_XATTR_FL)); 2249 2250 loc->xl_inode = inode; 2251 loc->xl_ops = &ocfs2_xa_block_loc_ops; 2252 loc->xl_storage = bh; 2253 loc->xl_entry = entry; 2254 loc->xl_size = le16_to_cpu(di->i_xattr_inline_size); 2255 loc->xl_header = 2256 (struct ocfs2_xattr_header *)(bh->b_data + bh->b_size - 2257 loc->xl_size); 2258 } 2259 2260 static void ocfs2_init_xattr_block_xa_loc(struct ocfs2_xa_loc *loc, 2261 struct inode *inode, 2262 struct buffer_head *bh, 2263 struct ocfs2_xattr_entry *entry) 2264 { 2265 struct ocfs2_xattr_block *xb = 2266 (struct ocfs2_xattr_block *)bh->b_data; 2267 2268 BUG_ON(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED); 2269 2270 loc->xl_inode = inode; 2271 loc->xl_ops = &ocfs2_xa_block_loc_ops; 2272 loc->xl_storage = bh; 2273 loc->xl_header = &(xb->xb_attrs.xb_header); 2274 loc->xl_entry = entry; 2275 loc->xl_size = bh->b_size - offsetof(struct ocfs2_xattr_block, 2276 xb_attrs.xb_header); 2277 } 2278 2279 static void ocfs2_init_xattr_bucket_xa_loc(struct ocfs2_xa_loc *loc, 2280 struct ocfs2_xattr_bucket *bucket, 2281 struct ocfs2_xattr_entry *entry) 2282 { 2283 loc->xl_inode = bucket->bu_inode; 2284 loc->xl_ops = &ocfs2_xa_bucket_loc_ops; 2285 loc->xl_storage = bucket; 2286 loc->xl_header = bucket_xh(bucket); 2287 loc->xl_entry = entry; 2288 loc->xl_size = OCFS2_XATTR_BUCKET_SIZE; 2289 } 2290 2291 /* 2292 * In xattr remove, if it is stored outside and refcounted, we may have 2293 * the chance to split the refcount tree. So need the allocators. 2294 */ 2295 static int ocfs2_lock_xattr_remove_allocators(struct inode *inode, 2296 struct ocfs2_xattr_value_root *xv, 2297 struct ocfs2_caching_info *ref_ci, 2298 struct buffer_head *ref_root_bh, 2299 struct ocfs2_alloc_context **meta_ac, 2300 int *ref_credits) 2301 { 2302 int ret, meta_add = 0; 2303 u32 p_cluster, num_clusters; 2304 unsigned int ext_flags; 2305 2306 *ref_credits = 0; 2307 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster, 2308 &num_clusters, 2309 &xv->xr_list, 2310 &ext_flags); 2311 if (ret) { 2312 mlog_errno(ret); 2313 goto out; 2314 } 2315 2316 if (!(ext_flags & OCFS2_EXT_REFCOUNTED)) 2317 goto out; 2318 2319 ret = ocfs2_refcounted_xattr_delete_need(inode, ref_ci, 2320 ref_root_bh, xv, 2321 &meta_add, ref_credits); 2322 if (ret) { 2323 mlog_errno(ret); 2324 goto out; 2325 } 2326 2327 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb), 2328 meta_add, meta_ac); 2329 if (ret) 2330 mlog_errno(ret); 2331 2332 out: 2333 return ret; 2334 } 2335 2336 static int ocfs2_remove_value_outside(struct inode*inode, 2337 struct ocfs2_xattr_value_buf *vb, 2338 struct ocfs2_xattr_header *header, 2339 struct ocfs2_caching_info *ref_ci, 2340 struct buffer_head *ref_root_bh) 2341 { 2342 int ret = 0, i, ref_credits; 2343 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2344 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, }; 2345 void *val; 2346 2347 ocfs2_init_dealloc_ctxt(&ctxt.dealloc); 2348 2349 for (i = 0; i < le16_to_cpu(header->xh_count); i++) { 2350 struct ocfs2_xattr_entry *entry = &header->xh_entries[i]; 2351 2352 if (ocfs2_xattr_is_local(entry)) 2353 continue; 2354 2355 val = (void *)header + 2356 le16_to_cpu(entry->xe_name_offset); 2357 vb->vb_xv = (struct ocfs2_xattr_value_root *) 2358 (val + OCFS2_XATTR_SIZE(entry->xe_name_len)); 2359 2360 ret = ocfs2_lock_xattr_remove_allocators(inode, vb->vb_xv, 2361 ref_ci, ref_root_bh, 2362 &ctxt.meta_ac, 2363 &ref_credits); 2364 2365 ctxt.handle = ocfs2_start_trans(osb, ref_credits + 2366 ocfs2_remove_extent_credits(osb->sb)); 2367 if (IS_ERR(ctxt.handle)) { 2368 ret = PTR_ERR(ctxt.handle); 2369 mlog_errno(ret); 2370 break; 2371 } 2372 2373 ret = ocfs2_xattr_value_truncate(inode, vb, 0, &ctxt); 2374 if (ret < 0) { 2375 mlog_errno(ret); 2376 break; 2377 } 2378 2379 ocfs2_commit_trans(osb, ctxt.handle); 2380 if (ctxt.meta_ac) { 2381 ocfs2_free_alloc_context(ctxt.meta_ac); 2382 ctxt.meta_ac = NULL; 2383 } 2384 } 2385 2386 if (ctxt.meta_ac) 2387 ocfs2_free_alloc_context(ctxt.meta_ac); 2388 ocfs2_schedule_truncate_log_flush(osb, 1); 2389 ocfs2_run_deallocs(osb, &ctxt.dealloc); 2390 return ret; 2391 } 2392 2393 static int ocfs2_xattr_ibody_remove(struct inode *inode, 2394 struct buffer_head *di_bh, 2395 struct ocfs2_caching_info *ref_ci, 2396 struct buffer_head *ref_root_bh) 2397 { 2398 2399 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 2400 struct ocfs2_xattr_header *header; 2401 int ret; 2402 struct ocfs2_xattr_value_buf vb = { 2403 .vb_bh = di_bh, 2404 .vb_access = ocfs2_journal_access_di, 2405 }; 2406 2407 header = (struct ocfs2_xattr_header *) 2408 ((void *)di + inode->i_sb->s_blocksize - 2409 le16_to_cpu(di->i_xattr_inline_size)); 2410 2411 ret = ocfs2_remove_value_outside(inode, &vb, header, 2412 ref_ci, ref_root_bh); 2413 2414 return ret; 2415 } 2416 2417 struct ocfs2_rm_xattr_bucket_para { 2418 struct ocfs2_caching_info *ref_ci; 2419 struct buffer_head *ref_root_bh; 2420 }; 2421 2422 static int ocfs2_xattr_block_remove(struct inode *inode, 2423 struct buffer_head *blk_bh, 2424 struct ocfs2_caching_info *ref_ci, 2425 struct buffer_head *ref_root_bh) 2426 { 2427 struct ocfs2_xattr_block *xb; 2428 int ret = 0; 2429 struct ocfs2_xattr_value_buf vb = { 2430 .vb_bh = blk_bh, 2431 .vb_access = ocfs2_journal_access_xb, 2432 }; 2433 struct ocfs2_rm_xattr_bucket_para args = { 2434 .ref_ci = ref_ci, 2435 .ref_root_bh = ref_root_bh, 2436 }; 2437 2438 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 2439 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 2440 struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header); 2441 ret = ocfs2_remove_value_outside(inode, &vb, header, 2442 ref_ci, ref_root_bh); 2443 } else 2444 ret = ocfs2_iterate_xattr_index_block(inode, 2445 blk_bh, 2446 ocfs2_rm_xattr_cluster, 2447 &args); 2448 2449 return ret; 2450 } 2451 2452 static int ocfs2_xattr_free_block(struct inode *inode, 2453 u64 block, 2454 struct ocfs2_caching_info *ref_ci, 2455 struct buffer_head *ref_root_bh) 2456 { 2457 struct inode *xb_alloc_inode; 2458 struct buffer_head *xb_alloc_bh = NULL; 2459 struct buffer_head *blk_bh = NULL; 2460 struct ocfs2_xattr_block *xb; 2461 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2462 handle_t *handle; 2463 int ret = 0; 2464 u64 blk, bg_blkno; 2465 u16 bit; 2466 2467 ret = ocfs2_read_xattr_block(inode, block, &blk_bh); 2468 if (ret < 0) { 2469 mlog_errno(ret); 2470 goto out; 2471 } 2472 2473 ret = ocfs2_xattr_block_remove(inode, blk_bh, ref_ci, ref_root_bh); 2474 if (ret < 0) { 2475 mlog_errno(ret); 2476 goto out; 2477 } 2478 2479 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 2480 blk = le64_to_cpu(xb->xb_blkno); 2481 bit = le16_to_cpu(xb->xb_suballoc_bit); 2482 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 2483 2484 xb_alloc_inode = ocfs2_get_system_file_inode(osb, 2485 EXTENT_ALLOC_SYSTEM_INODE, 2486 le16_to_cpu(xb->xb_suballoc_slot)); 2487 if (!xb_alloc_inode) { 2488 ret = -ENOMEM; 2489 mlog_errno(ret); 2490 goto out; 2491 } 2492 mutex_lock(&xb_alloc_inode->i_mutex); 2493 2494 ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1); 2495 if (ret < 0) { 2496 mlog_errno(ret); 2497 goto out_mutex; 2498 } 2499 2500 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE); 2501 if (IS_ERR(handle)) { 2502 ret = PTR_ERR(handle); 2503 mlog_errno(ret); 2504 goto out_unlock; 2505 } 2506 2507 ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh, 2508 bit, bg_blkno, 1); 2509 if (ret < 0) 2510 mlog_errno(ret); 2511 2512 ocfs2_commit_trans(osb, handle); 2513 out_unlock: 2514 ocfs2_inode_unlock(xb_alloc_inode, 1); 2515 brelse(xb_alloc_bh); 2516 out_mutex: 2517 mutex_unlock(&xb_alloc_inode->i_mutex); 2518 iput(xb_alloc_inode); 2519 out: 2520 brelse(blk_bh); 2521 return ret; 2522 } 2523 2524 /* 2525 * ocfs2_xattr_remove() 2526 * 2527 * Free extended attribute resources associated with this inode. 2528 */ 2529 int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh) 2530 { 2531 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2532 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 2533 struct ocfs2_refcount_tree *ref_tree = NULL; 2534 struct buffer_head *ref_root_bh = NULL; 2535 struct ocfs2_caching_info *ref_ci = NULL; 2536 handle_t *handle; 2537 int ret; 2538 2539 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 2540 return 0; 2541 2542 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 2543 return 0; 2544 2545 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) { 2546 ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb), 2547 le64_to_cpu(di->i_refcount_loc), 2548 1, &ref_tree, &ref_root_bh); 2549 if (ret) { 2550 mlog_errno(ret); 2551 goto out; 2552 } 2553 ref_ci = &ref_tree->rf_ci; 2554 2555 } 2556 2557 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 2558 ret = ocfs2_xattr_ibody_remove(inode, di_bh, 2559 ref_ci, ref_root_bh); 2560 if (ret < 0) { 2561 mlog_errno(ret); 2562 goto out; 2563 } 2564 } 2565 2566 if (di->i_xattr_loc) { 2567 ret = ocfs2_xattr_free_block(inode, 2568 le64_to_cpu(di->i_xattr_loc), 2569 ref_ci, ref_root_bh); 2570 if (ret < 0) { 2571 mlog_errno(ret); 2572 goto out; 2573 } 2574 } 2575 2576 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 2577 OCFS2_INODE_UPDATE_CREDITS); 2578 if (IS_ERR(handle)) { 2579 ret = PTR_ERR(handle); 2580 mlog_errno(ret); 2581 goto out; 2582 } 2583 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 2584 OCFS2_JOURNAL_ACCESS_WRITE); 2585 if (ret) { 2586 mlog_errno(ret); 2587 goto out_commit; 2588 } 2589 2590 di->i_xattr_loc = 0; 2591 2592 spin_lock(&oi->ip_lock); 2593 oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL); 2594 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 2595 spin_unlock(&oi->ip_lock); 2596 2597 ret = ocfs2_journal_dirty(handle, di_bh); 2598 if (ret < 0) 2599 mlog_errno(ret); 2600 out_commit: 2601 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 2602 out: 2603 if (ref_tree) 2604 ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1); 2605 brelse(ref_root_bh); 2606 return ret; 2607 } 2608 2609 static int ocfs2_xattr_has_space_inline(struct inode *inode, 2610 struct ocfs2_dinode *di) 2611 { 2612 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2613 unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size; 2614 int free; 2615 2616 if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE) 2617 return 0; 2618 2619 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 2620 struct ocfs2_inline_data *idata = &di->id2.i_data; 2621 free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size); 2622 } else if (ocfs2_inode_is_fast_symlink(inode)) { 2623 free = ocfs2_fast_symlink_chars(inode->i_sb) - 2624 le64_to_cpu(di->i_size); 2625 } else { 2626 struct ocfs2_extent_list *el = &di->id2.i_list; 2627 free = (le16_to_cpu(el->l_count) - 2628 le16_to_cpu(el->l_next_free_rec)) * 2629 sizeof(struct ocfs2_extent_rec); 2630 } 2631 if (free >= xattrsize) 2632 return 1; 2633 2634 return 0; 2635 } 2636 2637 /* 2638 * ocfs2_xattr_ibody_find() 2639 * 2640 * Find extended attribute in inode block and 2641 * fill search info into struct ocfs2_xattr_search. 2642 */ 2643 static int ocfs2_xattr_ibody_find(struct inode *inode, 2644 int name_index, 2645 const char *name, 2646 struct ocfs2_xattr_search *xs) 2647 { 2648 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2649 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 2650 int ret; 2651 int has_space = 0; 2652 2653 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) 2654 return 0; 2655 2656 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) { 2657 down_read(&oi->ip_alloc_sem); 2658 has_space = ocfs2_xattr_has_space_inline(inode, di); 2659 up_read(&oi->ip_alloc_sem); 2660 if (!has_space) 2661 return 0; 2662 } 2663 2664 xs->xattr_bh = xs->inode_bh; 2665 xs->end = (void *)di + inode->i_sb->s_blocksize; 2666 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) 2667 xs->header = (struct ocfs2_xattr_header *) 2668 (xs->end - le16_to_cpu(di->i_xattr_inline_size)); 2669 else 2670 xs->header = (struct ocfs2_xattr_header *) 2671 (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size); 2672 xs->base = (void *)xs->header; 2673 xs->here = xs->header->xh_entries; 2674 2675 /* Find the named attribute. */ 2676 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 2677 ret = ocfs2_xattr_find_entry(name_index, name, xs); 2678 if (ret && ret != -ENODATA) 2679 return ret; 2680 xs->not_found = ret; 2681 } 2682 2683 return 0; 2684 } 2685 2686 static int ocfs2_xattr_ibody_init(struct inode *inode, 2687 struct buffer_head *di_bh, 2688 struct ocfs2_xattr_set_ctxt *ctxt) 2689 { 2690 int ret; 2691 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2692 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 2693 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2694 unsigned int xattrsize = osb->s_xattr_inline_size; 2695 2696 if (!ocfs2_xattr_has_space_inline(inode, di)) { 2697 ret = -ENOSPC; 2698 goto out; 2699 } 2700 2701 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode), di_bh, 2702 OCFS2_JOURNAL_ACCESS_WRITE); 2703 if (ret) { 2704 mlog_errno(ret); 2705 goto out; 2706 } 2707 2708 /* 2709 * Adjust extent record count or inline data size 2710 * to reserve space for extended attribute. 2711 */ 2712 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 2713 struct ocfs2_inline_data *idata = &di->id2.i_data; 2714 le16_add_cpu(&idata->id_count, -xattrsize); 2715 } else if (!(ocfs2_inode_is_fast_symlink(inode))) { 2716 struct ocfs2_extent_list *el = &di->id2.i_list; 2717 le16_add_cpu(&el->l_count, -(xattrsize / 2718 sizeof(struct ocfs2_extent_rec))); 2719 } 2720 di->i_xattr_inline_size = cpu_to_le16(xattrsize); 2721 2722 spin_lock(&oi->ip_lock); 2723 oi->ip_dyn_features |= OCFS2_INLINE_XATTR_FL|OCFS2_HAS_XATTR_FL; 2724 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 2725 spin_unlock(&oi->ip_lock); 2726 2727 ret = ocfs2_journal_dirty(ctxt->handle, di_bh); 2728 if (ret < 0) 2729 mlog_errno(ret); 2730 2731 out: 2732 return ret; 2733 } 2734 2735 /* 2736 * ocfs2_xattr_ibody_set() 2737 * 2738 * Set, replace or remove an extended attribute into inode block. 2739 * 2740 */ 2741 static int ocfs2_xattr_ibody_set(struct inode *inode, 2742 struct ocfs2_xattr_info *xi, 2743 struct ocfs2_xattr_search *xs, 2744 struct ocfs2_xattr_set_ctxt *ctxt) 2745 { 2746 int ret; 2747 struct ocfs2_inode_info *oi = OCFS2_I(inode); 2748 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 2749 struct ocfs2_xa_loc loc; 2750 2751 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) 2752 return -ENOSPC; 2753 2754 down_write(&oi->ip_alloc_sem); 2755 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) { 2756 if (!ocfs2_xattr_has_space_inline(inode, di)) { 2757 ret = -ENOSPC; 2758 goto out; 2759 } 2760 } 2761 2762 if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) { 2763 ret = ocfs2_xattr_ibody_init(inode, xs->inode_bh, ctxt); 2764 if (ret) { 2765 if (ret != -ENOSPC) 2766 mlog_errno(ret); 2767 goto out; 2768 } 2769 } 2770 2771 ocfs2_init_dinode_xa_loc(&loc, inode, xs->inode_bh, 2772 xs->not_found ? NULL : xs->here); 2773 ret = ocfs2_xa_set(&loc, xi, ctxt); 2774 if (ret) { 2775 if (ret != -ENOSPC) 2776 mlog_errno(ret); 2777 goto out; 2778 } 2779 xs->here = loc.xl_entry; 2780 2781 out: 2782 up_write(&oi->ip_alloc_sem); 2783 2784 return ret; 2785 } 2786 2787 /* 2788 * ocfs2_xattr_block_find() 2789 * 2790 * Find extended attribute in external block and 2791 * fill search info into struct ocfs2_xattr_search. 2792 */ 2793 static int ocfs2_xattr_block_find(struct inode *inode, 2794 int name_index, 2795 const char *name, 2796 struct ocfs2_xattr_search *xs) 2797 { 2798 struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data; 2799 struct buffer_head *blk_bh = NULL; 2800 struct ocfs2_xattr_block *xb; 2801 int ret = 0; 2802 2803 if (!di->i_xattr_loc) 2804 return ret; 2805 2806 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc), 2807 &blk_bh); 2808 if (ret < 0) { 2809 mlog_errno(ret); 2810 return ret; 2811 } 2812 2813 xs->xattr_bh = blk_bh; 2814 xb = (struct ocfs2_xattr_block *)blk_bh->b_data; 2815 2816 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 2817 xs->header = &xb->xb_attrs.xb_header; 2818 xs->base = (void *)xs->header; 2819 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size; 2820 xs->here = xs->header->xh_entries; 2821 2822 ret = ocfs2_xattr_find_entry(name_index, name, xs); 2823 } else 2824 ret = ocfs2_xattr_index_block_find(inode, blk_bh, 2825 name_index, 2826 name, xs); 2827 2828 if (ret && ret != -ENODATA) { 2829 xs->xattr_bh = NULL; 2830 goto cleanup; 2831 } 2832 xs->not_found = ret; 2833 return 0; 2834 cleanup: 2835 brelse(blk_bh); 2836 2837 return ret; 2838 } 2839 2840 static int ocfs2_create_xattr_block(struct inode *inode, 2841 struct buffer_head *inode_bh, 2842 struct ocfs2_xattr_set_ctxt *ctxt, 2843 int indexed, 2844 struct buffer_head **ret_bh) 2845 { 2846 int ret; 2847 u16 suballoc_bit_start; 2848 u32 num_got; 2849 u64 first_blkno; 2850 struct ocfs2_dinode *di = (struct ocfs2_dinode *)inode_bh->b_data; 2851 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2852 struct buffer_head *new_bh = NULL; 2853 struct ocfs2_xattr_block *xblk; 2854 2855 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode), 2856 inode_bh, OCFS2_JOURNAL_ACCESS_CREATE); 2857 if (ret < 0) { 2858 mlog_errno(ret); 2859 goto end; 2860 } 2861 2862 ret = ocfs2_claim_metadata(osb, ctxt->handle, ctxt->meta_ac, 1, 2863 &suballoc_bit_start, &num_got, 2864 &first_blkno); 2865 if (ret < 0) { 2866 mlog_errno(ret); 2867 goto end; 2868 } 2869 2870 new_bh = sb_getblk(inode->i_sb, first_blkno); 2871 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh); 2872 2873 ret = ocfs2_journal_access_xb(ctxt->handle, INODE_CACHE(inode), 2874 new_bh, 2875 OCFS2_JOURNAL_ACCESS_CREATE); 2876 if (ret < 0) { 2877 mlog_errno(ret); 2878 goto end; 2879 } 2880 2881 /* Initialize ocfs2_xattr_block */ 2882 xblk = (struct ocfs2_xattr_block *)new_bh->b_data; 2883 memset(xblk, 0, inode->i_sb->s_blocksize); 2884 strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE); 2885 xblk->xb_suballoc_slot = cpu_to_le16(ctxt->meta_ac->ac_alloc_slot); 2886 xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start); 2887 xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation); 2888 xblk->xb_blkno = cpu_to_le64(first_blkno); 2889 if (indexed) { 2890 struct ocfs2_xattr_tree_root *xr = &xblk->xb_attrs.xb_root; 2891 xr->xt_clusters = cpu_to_le32(1); 2892 xr->xt_last_eb_blk = 0; 2893 xr->xt_list.l_tree_depth = 0; 2894 xr->xt_list.l_count = cpu_to_le16( 2895 ocfs2_xattr_recs_per_xb(inode->i_sb)); 2896 xr->xt_list.l_next_free_rec = cpu_to_le16(1); 2897 xblk->xb_flags = cpu_to_le16(OCFS2_XATTR_INDEXED); 2898 } 2899 ocfs2_journal_dirty(ctxt->handle, new_bh); 2900 2901 /* Add it to the inode */ 2902 di->i_xattr_loc = cpu_to_le64(first_blkno); 2903 2904 spin_lock(&OCFS2_I(inode)->ip_lock); 2905 OCFS2_I(inode)->ip_dyn_features |= OCFS2_HAS_XATTR_FL; 2906 di->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features); 2907 spin_unlock(&OCFS2_I(inode)->ip_lock); 2908 2909 ocfs2_journal_dirty(ctxt->handle, inode_bh); 2910 2911 *ret_bh = new_bh; 2912 new_bh = NULL; 2913 2914 end: 2915 brelse(new_bh); 2916 return ret; 2917 } 2918 2919 /* 2920 * ocfs2_xattr_block_set() 2921 * 2922 * Set, replace or remove an extended attribute into external block. 2923 * 2924 */ 2925 static int ocfs2_xattr_block_set(struct inode *inode, 2926 struct ocfs2_xattr_info *xi, 2927 struct ocfs2_xattr_search *xs, 2928 struct ocfs2_xattr_set_ctxt *ctxt) 2929 { 2930 struct buffer_head *new_bh = NULL; 2931 struct ocfs2_xattr_block *xblk = NULL; 2932 int ret; 2933 struct ocfs2_xa_loc loc; 2934 2935 if (!xs->xattr_bh) { 2936 ret = ocfs2_create_xattr_block(inode, xs->inode_bh, ctxt, 2937 0, &new_bh); 2938 if (ret) { 2939 mlog_errno(ret); 2940 goto end; 2941 } 2942 2943 xs->xattr_bh = new_bh; 2944 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data; 2945 xs->header = &xblk->xb_attrs.xb_header; 2946 xs->base = (void *)xs->header; 2947 xs->end = (void *)xblk + inode->i_sb->s_blocksize; 2948 xs->here = xs->header->xh_entries; 2949 } else 2950 xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data; 2951 2952 if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) { 2953 ocfs2_init_xattr_block_xa_loc(&loc, inode, xs->xattr_bh, 2954 xs->not_found ? NULL : xs->here); 2955 2956 ret = ocfs2_xa_set(&loc, xi, ctxt); 2957 if (!ret) 2958 xs->here = loc.xl_entry; 2959 else if (ret != -ENOSPC) 2960 goto end; 2961 else { 2962 ret = ocfs2_xattr_create_index_block(inode, xs, ctxt); 2963 if (ret) 2964 goto end; 2965 } 2966 } 2967 2968 if (le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED) 2969 ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs, ctxt); 2970 2971 end: 2972 return ret; 2973 } 2974 2975 /* Check whether the new xattr can be inserted into the inode. */ 2976 static int ocfs2_xattr_can_be_in_inode(struct inode *inode, 2977 struct ocfs2_xattr_info *xi, 2978 struct ocfs2_xattr_search *xs) 2979 { 2980 struct ocfs2_xattr_entry *last; 2981 int free, i; 2982 size_t min_offs = xs->end - xs->base; 2983 2984 if (!xs->header) 2985 return 0; 2986 2987 last = xs->header->xh_entries; 2988 2989 for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) { 2990 size_t offs = le16_to_cpu(last->xe_name_offset); 2991 if (offs < min_offs) 2992 min_offs = offs; 2993 last += 1; 2994 } 2995 2996 free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP; 2997 if (free < 0) 2998 return 0; 2999 3000 BUG_ON(!xs->not_found); 3001 3002 if (free >= (sizeof(struct ocfs2_xattr_entry) + namevalue_size_xi(xi))) 3003 return 1; 3004 3005 return 0; 3006 } 3007 3008 static int ocfs2_calc_xattr_set_need(struct inode *inode, 3009 struct ocfs2_dinode *di, 3010 struct ocfs2_xattr_info *xi, 3011 struct ocfs2_xattr_search *xis, 3012 struct ocfs2_xattr_search *xbs, 3013 int *clusters_need, 3014 int *meta_need, 3015 int *credits_need) 3016 { 3017 int ret = 0, old_in_xb = 0; 3018 int clusters_add = 0, meta_add = 0, credits = 0; 3019 struct buffer_head *bh = NULL; 3020 struct ocfs2_xattr_block *xb = NULL; 3021 struct ocfs2_xattr_entry *xe = NULL; 3022 struct ocfs2_xattr_value_root *xv = NULL; 3023 char *base = NULL; 3024 int name_offset, name_len = 0; 3025 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, 3026 xi->xi_value_len); 3027 u64 value_size; 3028 3029 /* 3030 * Calculate the clusters we need to write. 3031 * No matter whether we replace an old one or add a new one, 3032 * we need this for writing. 3033 */ 3034 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) 3035 credits += new_clusters * 3036 ocfs2_clusters_to_blocks(inode->i_sb, 1); 3037 3038 if (xis->not_found && xbs->not_found) { 3039 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3040 3041 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) { 3042 clusters_add += new_clusters; 3043 credits += ocfs2_calc_extend_credits(inode->i_sb, 3044 &def_xv.xv.xr_list, 3045 new_clusters); 3046 } 3047 3048 goto meta_guess; 3049 } 3050 3051 if (!xis->not_found) { 3052 xe = xis->here; 3053 name_offset = le16_to_cpu(xe->xe_name_offset); 3054 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3055 base = xis->base; 3056 credits += OCFS2_INODE_UPDATE_CREDITS; 3057 } else { 3058 int i, block_off = 0; 3059 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data; 3060 xe = xbs->here; 3061 name_offset = le16_to_cpu(xe->xe_name_offset); 3062 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3063 i = xbs->here - xbs->header->xh_entries; 3064 old_in_xb = 1; 3065 3066 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) { 3067 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, 3068 bucket_xh(xbs->bucket), 3069 i, &block_off, 3070 &name_offset); 3071 base = bucket_block(xbs->bucket, block_off); 3072 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3073 } else { 3074 base = xbs->base; 3075 credits += OCFS2_XATTR_BLOCK_UPDATE_CREDITS; 3076 } 3077 } 3078 3079 /* 3080 * delete a xattr doesn't need metadata and cluster allocation. 3081 * so just calculate the credits and return. 3082 * 3083 * The credits for removing the value tree will be extended 3084 * by ocfs2_remove_extent itself. 3085 */ 3086 if (!xi->xi_value) { 3087 if (!ocfs2_xattr_is_local(xe)) 3088 credits += ocfs2_remove_extent_credits(inode->i_sb); 3089 3090 goto out; 3091 } 3092 3093 /* do cluster allocation guess first. */ 3094 value_size = le64_to_cpu(xe->xe_value_size); 3095 3096 if (old_in_xb) { 3097 /* 3098 * In xattr set, we always try to set the xe in inode first, 3099 * so if it can be inserted into inode successfully, the old 3100 * one will be removed from the xattr block, and this xattr 3101 * will be inserted into inode as a new xattr in inode. 3102 */ 3103 if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) { 3104 clusters_add += new_clusters; 3105 credits += ocfs2_remove_extent_credits(inode->i_sb) + 3106 OCFS2_INODE_UPDATE_CREDITS; 3107 if (!ocfs2_xattr_is_local(xe)) 3108 credits += ocfs2_calc_extend_credits( 3109 inode->i_sb, 3110 &def_xv.xv.xr_list, 3111 new_clusters); 3112 goto out; 3113 } 3114 } 3115 3116 if (xi->xi_value_len > OCFS2_XATTR_INLINE_SIZE) { 3117 /* the new values will be stored outside. */ 3118 u32 old_clusters = 0; 3119 3120 if (!ocfs2_xattr_is_local(xe)) { 3121 old_clusters = ocfs2_clusters_for_bytes(inode->i_sb, 3122 value_size); 3123 xv = (struct ocfs2_xattr_value_root *) 3124 (base + name_offset + name_len); 3125 value_size = OCFS2_XATTR_ROOT_SIZE; 3126 } else 3127 xv = &def_xv.xv; 3128 3129 if (old_clusters >= new_clusters) { 3130 credits += ocfs2_remove_extent_credits(inode->i_sb); 3131 goto out; 3132 } else { 3133 meta_add += ocfs2_extend_meta_needed(&xv->xr_list); 3134 clusters_add += new_clusters - old_clusters; 3135 credits += ocfs2_calc_extend_credits(inode->i_sb, 3136 &xv->xr_list, 3137 new_clusters - 3138 old_clusters); 3139 if (value_size >= OCFS2_XATTR_ROOT_SIZE) 3140 goto out; 3141 } 3142 } else { 3143 /* 3144 * Now the new value will be stored inside. So if the new 3145 * value is smaller than the size of value root or the old 3146 * value, we don't need any allocation, otherwise we have 3147 * to guess metadata allocation. 3148 */ 3149 if ((ocfs2_xattr_is_local(xe) && 3150 (value_size >= xi->xi_value_len)) || 3151 (!ocfs2_xattr_is_local(xe) && 3152 OCFS2_XATTR_ROOT_SIZE >= xi->xi_value_len)) 3153 goto out; 3154 } 3155 3156 meta_guess: 3157 /* calculate metadata allocation. */ 3158 if (di->i_xattr_loc) { 3159 if (!xbs->xattr_bh) { 3160 ret = ocfs2_read_xattr_block(inode, 3161 le64_to_cpu(di->i_xattr_loc), 3162 &bh); 3163 if (ret) { 3164 mlog_errno(ret); 3165 goto out; 3166 } 3167 3168 xb = (struct ocfs2_xattr_block *)bh->b_data; 3169 } else 3170 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data; 3171 3172 /* 3173 * If there is already an xattr tree, good, we can calculate 3174 * like other b-trees. Otherwise we may have the chance of 3175 * create a tree, the credit calculation is borrowed from 3176 * ocfs2_calc_extend_credits with root_el = NULL. And the 3177 * new tree will be cluster based, so no meta is needed. 3178 */ 3179 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) { 3180 struct ocfs2_extent_list *el = 3181 &xb->xb_attrs.xb_root.xt_list; 3182 meta_add += ocfs2_extend_meta_needed(el); 3183 credits += ocfs2_calc_extend_credits(inode->i_sb, 3184 el, 1); 3185 } else 3186 credits += OCFS2_SUBALLOC_ALLOC + 1; 3187 3188 /* 3189 * This cluster will be used either for new bucket or for 3190 * new xattr block. 3191 * If the cluster size is the same as the bucket size, one 3192 * more is needed since we may need to extend the bucket 3193 * also. 3194 */ 3195 clusters_add += 1; 3196 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3197 if (OCFS2_XATTR_BUCKET_SIZE == 3198 OCFS2_SB(inode->i_sb)->s_clustersize) { 3199 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3200 clusters_add += 1; 3201 } 3202 } else { 3203 meta_add += 1; 3204 credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS; 3205 } 3206 out: 3207 if (clusters_need) 3208 *clusters_need = clusters_add; 3209 if (meta_need) 3210 *meta_need = meta_add; 3211 if (credits_need) 3212 *credits_need = credits; 3213 brelse(bh); 3214 return ret; 3215 } 3216 3217 static int ocfs2_init_xattr_set_ctxt(struct inode *inode, 3218 struct ocfs2_dinode *di, 3219 struct ocfs2_xattr_info *xi, 3220 struct ocfs2_xattr_search *xis, 3221 struct ocfs2_xattr_search *xbs, 3222 struct ocfs2_xattr_set_ctxt *ctxt, 3223 int extra_meta, 3224 int *credits) 3225 { 3226 int clusters_add, meta_add, ret; 3227 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3228 3229 memset(ctxt, 0, sizeof(struct ocfs2_xattr_set_ctxt)); 3230 3231 ocfs2_init_dealloc_ctxt(&ctxt->dealloc); 3232 3233 ret = ocfs2_calc_xattr_set_need(inode, di, xi, xis, xbs, 3234 &clusters_add, &meta_add, credits); 3235 if (ret) { 3236 mlog_errno(ret); 3237 return ret; 3238 } 3239 3240 meta_add += extra_meta; 3241 mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, " 3242 "credits = %d\n", xi->xi_name, meta_add, clusters_add, *credits); 3243 3244 if (meta_add) { 3245 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, 3246 &ctxt->meta_ac); 3247 if (ret) { 3248 mlog_errno(ret); 3249 goto out; 3250 } 3251 } 3252 3253 if (clusters_add) { 3254 ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac); 3255 if (ret) 3256 mlog_errno(ret); 3257 } 3258 out: 3259 if (ret) { 3260 if (ctxt->meta_ac) { 3261 ocfs2_free_alloc_context(ctxt->meta_ac); 3262 ctxt->meta_ac = NULL; 3263 } 3264 3265 /* 3266 * We cannot have an error and a non null ctxt->data_ac. 3267 */ 3268 } 3269 3270 return ret; 3271 } 3272 3273 static int __ocfs2_xattr_set_handle(struct inode *inode, 3274 struct ocfs2_dinode *di, 3275 struct ocfs2_xattr_info *xi, 3276 struct ocfs2_xattr_search *xis, 3277 struct ocfs2_xattr_search *xbs, 3278 struct ocfs2_xattr_set_ctxt *ctxt) 3279 { 3280 int ret = 0, credits, old_found; 3281 3282 if (!xi->xi_value) { 3283 /* Remove existing extended attribute */ 3284 if (!xis->not_found) 3285 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt); 3286 else if (!xbs->not_found) 3287 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt); 3288 } else { 3289 /* We always try to set extended attribute into inode first*/ 3290 ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt); 3291 if (!ret && !xbs->not_found) { 3292 /* 3293 * If succeed and that extended attribute existing in 3294 * external block, then we will remove it. 3295 */ 3296 xi->xi_value = NULL; 3297 xi->xi_value_len = 0; 3298 3299 old_found = xis->not_found; 3300 xis->not_found = -ENODATA; 3301 ret = ocfs2_calc_xattr_set_need(inode, 3302 di, 3303 xi, 3304 xis, 3305 xbs, 3306 NULL, 3307 NULL, 3308 &credits); 3309 xis->not_found = old_found; 3310 if (ret) { 3311 mlog_errno(ret); 3312 goto out; 3313 } 3314 3315 ret = ocfs2_extend_trans(ctxt->handle, credits + 3316 ctxt->handle->h_buffer_credits); 3317 if (ret) { 3318 mlog_errno(ret); 3319 goto out; 3320 } 3321 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt); 3322 } else if (ret == -ENOSPC) { 3323 if (di->i_xattr_loc && !xbs->xattr_bh) { 3324 ret = ocfs2_xattr_block_find(inode, 3325 xi->xi_name_index, 3326 xi->xi_name, xbs); 3327 if (ret) 3328 goto out; 3329 3330 old_found = xis->not_found; 3331 xis->not_found = -ENODATA; 3332 ret = ocfs2_calc_xattr_set_need(inode, 3333 di, 3334 xi, 3335 xis, 3336 xbs, 3337 NULL, 3338 NULL, 3339 &credits); 3340 xis->not_found = old_found; 3341 if (ret) { 3342 mlog_errno(ret); 3343 goto out; 3344 } 3345 3346 ret = ocfs2_extend_trans(ctxt->handle, credits + 3347 ctxt->handle->h_buffer_credits); 3348 if (ret) { 3349 mlog_errno(ret); 3350 goto out; 3351 } 3352 } 3353 /* 3354 * If no space in inode, we will set extended attribute 3355 * into external block. 3356 */ 3357 ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt); 3358 if (ret) 3359 goto out; 3360 if (!xis->not_found) { 3361 /* 3362 * If succeed and that extended attribute 3363 * existing in inode, we will remove it. 3364 */ 3365 xi->xi_value = NULL; 3366 xi->xi_value_len = 0; 3367 xbs->not_found = -ENODATA; 3368 ret = ocfs2_calc_xattr_set_need(inode, 3369 di, 3370 xi, 3371 xis, 3372 xbs, 3373 NULL, 3374 NULL, 3375 &credits); 3376 if (ret) { 3377 mlog_errno(ret); 3378 goto out; 3379 } 3380 3381 ret = ocfs2_extend_trans(ctxt->handle, credits + 3382 ctxt->handle->h_buffer_credits); 3383 if (ret) { 3384 mlog_errno(ret); 3385 goto out; 3386 } 3387 ret = ocfs2_xattr_ibody_set(inode, xi, 3388 xis, ctxt); 3389 } 3390 } 3391 } 3392 3393 if (!ret) { 3394 /* Update inode ctime. */ 3395 ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode), 3396 xis->inode_bh, 3397 OCFS2_JOURNAL_ACCESS_WRITE); 3398 if (ret) { 3399 mlog_errno(ret); 3400 goto out; 3401 } 3402 3403 inode->i_ctime = CURRENT_TIME; 3404 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 3405 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 3406 ocfs2_journal_dirty(ctxt->handle, xis->inode_bh); 3407 } 3408 out: 3409 return ret; 3410 } 3411 3412 /* 3413 * This function only called duing creating inode 3414 * for init security/acl xattrs of the new inode. 3415 * All transanction credits have been reserved in mknod. 3416 */ 3417 int ocfs2_xattr_set_handle(handle_t *handle, 3418 struct inode *inode, 3419 struct buffer_head *di_bh, 3420 int name_index, 3421 const char *name, 3422 const void *value, 3423 size_t value_len, 3424 int flags, 3425 struct ocfs2_alloc_context *meta_ac, 3426 struct ocfs2_alloc_context *data_ac) 3427 { 3428 struct ocfs2_dinode *di; 3429 int ret; 3430 3431 struct ocfs2_xattr_info xi = { 3432 .xi_name_index = name_index, 3433 .xi_name = name, 3434 .xi_name_len = strlen(name), 3435 .xi_value = value, 3436 .xi_value_len = value_len, 3437 }; 3438 3439 struct ocfs2_xattr_search xis = { 3440 .not_found = -ENODATA, 3441 }; 3442 3443 struct ocfs2_xattr_search xbs = { 3444 .not_found = -ENODATA, 3445 }; 3446 3447 struct ocfs2_xattr_set_ctxt ctxt = { 3448 .handle = handle, 3449 .meta_ac = meta_ac, 3450 .data_ac = data_ac, 3451 }; 3452 3453 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 3454 return -EOPNOTSUPP; 3455 3456 /* 3457 * In extreme situation, may need xattr bucket when 3458 * block size is too small. And we have already reserved 3459 * the credits for bucket in mknod. 3460 */ 3461 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) { 3462 xbs.bucket = ocfs2_xattr_bucket_new(inode); 3463 if (!xbs.bucket) { 3464 mlog_errno(-ENOMEM); 3465 return -ENOMEM; 3466 } 3467 } 3468 3469 xis.inode_bh = xbs.inode_bh = di_bh; 3470 di = (struct ocfs2_dinode *)di_bh->b_data; 3471 3472 down_write(&OCFS2_I(inode)->ip_xattr_sem); 3473 3474 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis); 3475 if (ret) 3476 goto cleanup; 3477 if (xis.not_found) { 3478 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs); 3479 if (ret) 3480 goto cleanup; 3481 } 3482 3483 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt); 3484 3485 cleanup: 3486 up_write(&OCFS2_I(inode)->ip_xattr_sem); 3487 brelse(xbs.xattr_bh); 3488 ocfs2_xattr_bucket_free(xbs.bucket); 3489 3490 return ret; 3491 } 3492 3493 /* 3494 * ocfs2_xattr_set() 3495 * 3496 * Set, replace or remove an extended attribute for this inode. 3497 * value is NULL to remove an existing extended attribute, else either 3498 * create or replace an extended attribute. 3499 */ 3500 int ocfs2_xattr_set(struct inode *inode, 3501 int name_index, 3502 const char *name, 3503 const void *value, 3504 size_t value_len, 3505 int flags) 3506 { 3507 struct buffer_head *di_bh = NULL; 3508 struct ocfs2_dinode *di; 3509 int ret, credits, ref_meta = 0, ref_credits = 0; 3510 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3511 struct inode *tl_inode = osb->osb_tl_inode; 3512 struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, }; 3513 struct ocfs2_refcount_tree *ref_tree = NULL; 3514 3515 struct ocfs2_xattr_info xi = { 3516 .xi_name_index = name_index, 3517 .xi_name = name, 3518 .xi_name_len = strlen(name), 3519 .xi_value = value, 3520 .xi_value_len = value_len, 3521 }; 3522 3523 struct ocfs2_xattr_search xis = { 3524 .not_found = -ENODATA, 3525 }; 3526 3527 struct ocfs2_xattr_search xbs = { 3528 .not_found = -ENODATA, 3529 }; 3530 3531 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) 3532 return -EOPNOTSUPP; 3533 3534 /* 3535 * Only xbs will be used on indexed trees. xis doesn't need a 3536 * bucket. 3537 */ 3538 xbs.bucket = ocfs2_xattr_bucket_new(inode); 3539 if (!xbs.bucket) { 3540 mlog_errno(-ENOMEM); 3541 return -ENOMEM; 3542 } 3543 3544 ret = ocfs2_inode_lock(inode, &di_bh, 1); 3545 if (ret < 0) { 3546 mlog_errno(ret); 3547 goto cleanup_nolock; 3548 } 3549 xis.inode_bh = xbs.inode_bh = di_bh; 3550 di = (struct ocfs2_dinode *)di_bh->b_data; 3551 3552 down_write(&OCFS2_I(inode)->ip_xattr_sem); 3553 /* 3554 * Scan inode and external block to find the same name 3555 * extended attribute and collect search infomation. 3556 */ 3557 ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis); 3558 if (ret) 3559 goto cleanup; 3560 if (xis.not_found) { 3561 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs); 3562 if (ret) 3563 goto cleanup; 3564 } 3565 3566 if (xis.not_found && xbs.not_found) { 3567 ret = -ENODATA; 3568 if (flags & XATTR_REPLACE) 3569 goto cleanup; 3570 ret = 0; 3571 if (!value) 3572 goto cleanup; 3573 } else { 3574 ret = -EEXIST; 3575 if (flags & XATTR_CREATE) 3576 goto cleanup; 3577 } 3578 3579 /* Check whether the value is refcounted and do some prepartion. */ 3580 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL && 3581 (!xis.not_found || !xbs.not_found)) { 3582 ret = ocfs2_prepare_refcount_xattr(inode, di, &xi, 3583 &xis, &xbs, &ref_tree, 3584 &ref_meta, &ref_credits); 3585 if (ret) { 3586 mlog_errno(ret); 3587 goto cleanup; 3588 } 3589 } 3590 3591 mutex_lock(&tl_inode->i_mutex); 3592 3593 if (ocfs2_truncate_log_needs_flush(osb)) { 3594 ret = __ocfs2_flush_truncate_log(osb); 3595 if (ret < 0) { 3596 mutex_unlock(&tl_inode->i_mutex); 3597 mlog_errno(ret); 3598 goto cleanup; 3599 } 3600 } 3601 mutex_unlock(&tl_inode->i_mutex); 3602 3603 ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis, 3604 &xbs, &ctxt, ref_meta, &credits); 3605 if (ret) { 3606 mlog_errno(ret); 3607 goto cleanup; 3608 } 3609 3610 /* we need to update inode's ctime field, so add credit for it. */ 3611 credits += OCFS2_INODE_UPDATE_CREDITS; 3612 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits); 3613 if (IS_ERR(ctxt.handle)) { 3614 ret = PTR_ERR(ctxt.handle); 3615 mlog_errno(ret); 3616 goto cleanup; 3617 } 3618 3619 ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt); 3620 3621 ocfs2_commit_trans(osb, ctxt.handle); 3622 3623 if (ctxt.data_ac) 3624 ocfs2_free_alloc_context(ctxt.data_ac); 3625 if (ctxt.meta_ac) 3626 ocfs2_free_alloc_context(ctxt.meta_ac); 3627 if (ocfs2_dealloc_has_cluster(&ctxt.dealloc)) 3628 ocfs2_schedule_truncate_log_flush(osb, 1); 3629 ocfs2_run_deallocs(osb, &ctxt.dealloc); 3630 3631 cleanup: 3632 if (ref_tree) 3633 ocfs2_unlock_refcount_tree(osb, ref_tree, 1); 3634 up_write(&OCFS2_I(inode)->ip_xattr_sem); 3635 if (!value && !ret) { 3636 ret = ocfs2_try_remove_refcount_tree(inode, di_bh); 3637 if (ret) 3638 mlog_errno(ret); 3639 } 3640 ocfs2_inode_unlock(inode, 1); 3641 cleanup_nolock: 3642 brelse(di_bh); 3643 brelse(xbs.xattr_bh); 3644 ocfs2_xattr_bucket_free(xbs.bucket); 3645 3646 return ret; 3647 } 3648 3649 /* 3650 * Find the xattr extent rec which may contains name_hash. 3651 * e_cpos will be the first name hash of the xattr rec. 3652 * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list. 3653 */ 3654 static int ocfs2_xattr_get_rec(struct inode *inode, 3655 u32 name_hash, 3656 u64 *p_blkno, 3657 u32 *e_cpos, 3658 u32 *num_clusters, 3659 struct ocfs2_extent_list *el) 3660 { 3661 int ret = 0, i; 3662 struct buffer_head *eb_bh = NULL; 3663 struct ocfs2_extent_block *eb; 3664 struct ocfs2_extent_rec *rec = NULL; 3665 u64 e_blkno = 0; 3666 3667 if (el->l_tree_depth) { 3668 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, name_hash, 3669 &eb_bh); 3670 if (ret) { 3671 mlog_errno(ret); 3672 goto out; 3673 } 3674 3675 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 3676 el = &eb->h_list; 3677 3678 if (el->l_tree_depth) { 3679 ocfs2_error(inode->i_sb, 3680 "Inode %lu has non zero tree depth in " 3681 "xattr tree block %llu\n", inode->i_ino, 3682 (unsigned long long)eb_bh->b_blocknr); 3683 ret = -EROFS; 3684 goto out; 3685 } 3686 } 3687 3688 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) { 3689 rec = &el->l_recs[i]; 3690 3691 if (le32_to_cpu(rec->e_cpos) <= name_hash) { 3692 e_blkno = le64_to_cpu(rec->e_blkno); 3693 break; 3694 } 3695 } 3696 3697 if (!e_blkno) { 3698 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " 3699 "record (%u, %u, 0) in xattr", inode->i_ino, 3700 le32_to_cpu(rec->e_cpos), 3701 ocfs2_rec_clusters(el, rec)); 3702 ret = -EROFS; 3703 goto out; 3704 } 3705 3706 *p_blkno = le64_to_cpu(rec->e_blkno); 3707 *num_clusters = le16_to_cpu(rec->e_leaf_clusters); 3708 if (e_cpos) 3709 *e_cpos = le32_to_cpu(rec->e_cpos); 3710 out: 3711 brelse(eb_bh); 3712 return ret; 3713 } 3714 3715 typedef int (xattr_bucket_func)(struct inode *inode, 3716 struct ocfs2_xattr_bucket *bucket, 3717 void *para); 3718 3719 static int ocfs2_find_xe_in_bucket(struct inode *inode, 3720 struct ocfs2_xattr_bucket *bucket, 3721 int name_index, 3722 const char *name, 3723 u32 name_hash, 3724 u16 *xe_index, 3725 int *found) 3726 { 3727 int i, ret = 0, cmp = 1, block_off, new_offset; 3728 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 3729 size_t name_len = strlen(name); 3730 struct ocfs2_xattr_entry *xe = NULL; 3731 char *xe_name; 3732 3733 /* 3734 * We don't use binary search in the bucket because there 3735 * may be multiple entries with the same name hash. 3736 */ 3737 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 3738 xe = &xh->xh_entries[i]; 3739 3740 if (name_hash > le32_to_cpu(xe->xe_name_hash)) 3741 continue; 3742 else if (name_hash < le32_to_cpu(xe->xe_name_hash)) 3743 break; 3744 3745 cmp = name_index - ocfs2_xattr_get_type(xe); 3746 if (!cmp) 3747 cmp = name_len - xe->xe_name_len; 3748 if (cmp) 3749 continue; 3750 3751 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, 3752 xh, 3753 i, 3754 &block_off, 3755 &new_offset); 3756 if (ret) { 3757 mlog_errno(ret); 3758 break; 3759 } 3760 3761 3762 xe_name = bucket_block(bucket, block_off) + new_offset; 3763 if (!memcmp(name, xe_name, name_len)) { 3764 *xe_index = i; 3765 *found = 1; 3766 ret = 0; 3767 break; 3768 } 3769 } 3770 3771 return ret; 3772 } 3773 3774 /* 3775 * Find the specified xattr entry in a series of buckets. 3776 * This series start from p_blkno and last for num_clusters. 3777 * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains 3778 * the num of the valid buckets. 3779 * 3780 * Return the buffer_head this xattr should reside in. And if the xattr's 3781 * hash is in the gap of 2 buckets, return the lower bucket. 3782 */ 3783 static int ocfs2_xattr_bucket_find(struct inode *inode, 3784 int name_index, 3785 const char *name, 3786 u32 name_hash, 3787 u64 p_blkno, 3788 u32 first_hash, 3789 u32 num_clusters, 3790 struct ocfs2_xattr_search *xs) 3791 { 3792 int ret, found = 0; 3793 struct ocfs2_xattr_header *xh = NULL; 3794 struct ocfs2_xattr_entry *xe = NULL; 3795 u16 index = 0; 3796 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3797 int low_bucket = 0, bucket, high_bucket; 3798 struct ocfs2_xattr_bucket *search; 3799 u32 last_hash; 3800 u64 blkno, lower_blkno = 0; 3801 3802 search = ocfs2_xattr_bucket_new(inode); 3803 if (!search) { 3804 ret = -ENOMEM; 3805 mlog_errno(ret); 3806 goto out; 3807 } 3808 3809 ret = ocfs2_read_xattr_bucket(search, p_blkno); 3810 if (ret) { 3811 mlog_errno(ret); 3812 goto out; 3813 } 3814 3815 xh = bucket_xh(search); 3816 high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1; 3817 while (low_bucket <= high_bucket) { 3818 ocfs2_xattr_bucket_relse(search); 3819 3820 bucket = (low_bucket + high_bucket) / 2; 3821 blkno = p_blkno + bucket * blk_per_bucket; 3822 ret = ocfs2_read_xattr_bucket(search, blkno); 3823 if (ret) { 3824 mlog_errno(ret); 3825 goto out; 3826 } 3827 3828 xh = bucket_xh(search); 3829 xe = &xh->xh_entries[0]; 3830 if (name_hash < le32_to_cpu(xe->xe_name_hash)) { 3831 high_bucket = bucket - 1; 3832 continue; 3833 } 3834 3835 /* 3836 * Check whether the hash of the last entry in our 3837 * bucket is larger than the search one. for an empty 3838 * bucket, the last one is also the first one. 3839 */ 3840 if (xh->xh_count) 3841 xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1]; 3842 3843 last_hash = le32_to_cpu(xe->xe_name_hash); 3844 3845 /* record lower_blkno which may be the insert place. */ 3846 lower_blkno = blkno; 3847 3848 if (name_hash > le32_to_cpu(xe->xe_name_hash)) { 3849 low_bucket = bucket + 1; 3850 continue; 3851 } 3852 3853 /* the searched xattr should reside in this bucket if exists. */ 3854 ret = ocfs2_find_xe_in_bucket(inode, search, 3855 name_index, name, name_hash, 3856 &index, &found); 3857 if (ret) { 3858 mlog_errno(ret); 3859 goto out; 3860 } 3861 break; 3862 } 3863 3864 /* 3865 * Record the bucket we have found. 3866 * When the xattr's hash value is in the gap of 2 buckets, we will 3867 * always set it to the previous bucket. 3868 */ 3869 if (!lower_blkno) 3870 lower_blkno = p_blkno; 3871 3872 /* This should be in cache - we just read it during the search */ 3873 ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno); 3874 if (ret) { 3875 mlog_errno(ret); 3876 goto out; 3877 } 3878 3879 xs->header = bucket_xh(xs->bucket); 3880 xs->base = bucket_block(xs->bucket, 0); 3881 xs->end = xs->base + inode->i_sb->s_blocksize; 3882 3883 if (found) { 3884 xs->here = &xs->header->xh_entries[index]; 3885 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name, 3886 (unsigned long long)bucket_blkno(xs->bucket), index); 3887 } else 3888 ret = -ENODATA; 3889 3890 out: 3891 ocfs2_xattr_bucket_free(search); 3892 return ret; 3893 } 3894 3895 static int ocfs2_xattr_index_block_find(struct inode *inode, 3896 struct buffer_head *root_bh, 3897 int name_index, 3898 const char *name, 3899 struct ocfs2_xattr_search *xs) 3900 { 3901 int ret; 3902 struct ocfs2_xattr_block *xb = 3903 (struct ocfs2_xattr_block *)root_bh->b_data; 3904 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root; 3905 struct ocfs2_extent_list *el = &xb_root->xt_list; 3906 u64 p_blkno = 0; 3907 u32 first_hash, num_clusters = 0; 3908 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name)); 3909 3910 if (le16_to_cpu(el->l_next_free_rec) == 0) 3911 return -ENODATA; 3912 3913 mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n", 3914 name, name_hash, name_index); 3915 3916 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash, 3917 &num_clusters, el); 3918 if (ret) { 3919 mlog_errno(ret); 3920 goto out; 3921 } 3922 3923 BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash); 3924 3925 mlog(0, "find xattr extent rec %u clusters from %llu, the first hash " 3926 "in the rec is %u\n", num_clusters, (unsigned long long)p_blkno, 3927 first_hash); 3928 3929 ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash, 3930 p_blkno, first_hash, num_clusters, xs); 3931 3932 out: 3933 return ret; 3934 } 3935 3936 static int ocfs2_iterate_xattr_buckets(struct inode *inode, 3937 u64 blkno, 3938 u32 clusters, 3939 xattr_bucket_func *func, 3940 void *para) 3941 { 3942 int i, ret = 0; 3943 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)); 3944 u32 num_buckets = clusters * bpc; 3945 struct ocfs2_xattr_bucket *bucket; 3946 3947 bucket = ocfs2_xattr_bucket_new(inode); 3948 if (!bucket) { 3949 mlog_errno(-ENOMEM); 3950 return -ENOMEM; 3951 } 3952 3953 mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n", 3954 clusters, (unsigned long long)blkno); 3955 3956 for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) { 3957 ret = ocfs2_read_xattr_bucket(bucket, blkno); 3958 if (ret) { 3959 mlog_errno(ret); 3960 break; 3961 } 3962 3963 /* 3964 * The real bucket num in this series of blocks is stored 3965 * in the 1st bucket. 3966 */ 3967 if (i == 0) 3968 num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets); 3969 3970 mlog(0, "iterating xattr bucket %llu, first hash %u\n", 3971 (unsigned long long)blkno, 3972 le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash)); 3973 if (func) { 3974 ret = func(inode, bucket, para); 3975 if (ret && ret != -ERANGE) 3976 mlog_errno(ret); 3977 /* Fall through to bucket_relse() */ 3978 } 3979 3980 ocfs2_xattr_bucket_relse(bucket); 3981 if (ret) 3982 break; 3983 } 3984 3985 ocfs2_xattr_bucket_free(bucket); 3986 return ret; 3987 } 3988 3989 struct ocfs2_xattr_tree_list { 3990 char *buffer; 3991 size_t buffer_size; 3992 size_t result; 3993 }; 3994 3995 static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb, 3996 struct ocfs2_xattr_header *xh, 3997 int index, 3998 int *block_off, 3999 int *new_offset) 4000 { 4001 u16 name_offset; 4002 4003 if (index < 0 || index >= le16_to_cpu(xh->xh_count)) 4004 return -EINVAL; 4005 4006 name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset); 4007 4008 *block_off = name_offset >> sb->s_blocksize_bits; 4009 *new_offset = name_offset % sb->s_blocksize; 4010 4011 return 0; 4012 } 4013 4014 static int ocfs2_list_xattr_bucket(struct inode *inode, 4015 struct ocfs2_xattr_bucket *bucket, 4016 void *para) 4017 { 4018 int ret = 0, type; 4019 struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para; 4020 int i, block_off, new_offset; 4021 const char *prefix, *name; 4022 4023 for (i = 0 ; i < le16_to_cpu(bucket_xh(bucket)->xh_count); i++) { 4024 struct ocfs2_xattr_entry *entry = &bucket_xh(bucket)->xh_entries[i]; 4025 type = ocfs2_xattr_get_type(entry); 4026 prefix = ocfs2_xattr_prefix(type); 4027 4028 if (prefix) { 4029 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, 4030 bucket_xh(bucket), 4031 i, 4032 &block_off, 4033 &new_offset); 4034 if (ret) 4035 break; 4036 4037 name = (const char *)bucket_block(bucket, block_off) + 4038 new_offset; 4039 ret = ocfs2_xattr_list_entry(xl->buffer, 4040 xl->buffer_size, 4041 &xl->result, 4042 prefix, name, 4043 entry->xe_name_len); 4044 if (ret) 4045 break; 4046 } 4047 } 4048 4049 return ret; 4050 } 4051 4052 static int ocfs2_iterate_xattr_index_block(struct inode *inode, 4053 struct buffer_head *blk_bh, 4054 xattr_tree_rec_func *rec_func, 4055 void *para) 4056 { 4057 struct ocfs2_xattr_block *xb = 4058 (struct ocfs2_xattr_block *)blk_bh->b_data; 4059 struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list; 4060 int ret = 0; 4061 u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0; 4062 u64 p_blkno = 0; 4063 4064 if (!el->l_next_free_rec || !rec_func) 4065 return 0; 4066 4067 while (name_hash > 0) { 4068 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, 4069 &e_cpos, &num_clusters, el); 4070 if (ret) { 4071 mlog_errno(ret); 4072 break; 4073 } 4074 4075 ret = rec_func(inode, blk_bh, p_blkno, e_cpos, 4076 num_clusters, para); 4077 if (ret) { 4078 if (ret != -ERANGE) 4079 mlog_errno(ret); 4080 break; 4081 } 4082 4083 if (e_cpos == 0) 4084 break; 4085 4086 name_hash = e_cpos - 1; 4087 } 4088 4089 return ret; 4090 4091 } 4092 4093 static int ocfs2_list_xattr_tree_rec(struct inode *inode, 4094 struct buffer_head *root_bh, 4095 u64 blkno, u32 cpos, u32 len, void *para) 4096 { 4097 return ocfs2_iterate_xattr_buckets(inode, blkno, len, 4098 ocfs2_list_xattr_bucket, para); 4099 } 4100 4101 static int ocfs2_xattr_tree_list_index_block(struct inode *inode, 4102 struct buffer_head *blk_bh, 4103 char *buffer, 4104 size_t buffer_size) 4105 { 4106 int ret; 4107 struct ocfs2_xattr_tree_list xl = { 4108 .buffer = buffer, 4109 .buffer_size = buffer_size, 4110 .result = 0, 4111 }; 4112 4113 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh, 4114 ocfs2_list_xattr_tree_rec, &xl); 4115 if (ret) { 4116 mlog_errno(ret); 4117 goto out; 4118 } 4119 4120 ret = xl.result; 4121 out: 4122 return ret; 4123 } 4124 4125 static int cmp_xe(const void *a, const void *b) 4126 { 4127 const struct ocfs2_xattr_entry *l = a, *r = b; 4128 u32 l_hash = le32_to_cpu(l->xe_name_hash); 4129 u32 r_hash = le32_to_cpu(r->xe_name_hash); 4130 4131 if (l_hash > r_hash) 4132 return 1; 4133 if (l_hash < r_hash) 4134 return -1; 4135 return 0; 4136 } 4137 4138 static void swap_xe(void *a, void *b, int size) 4139 { 4140 struct ocfs2_xattr_entry *l = a, *r = b, tmp; 4141 4142 tmp = *l; 4143 memcpy(l, r, sizeof(struct ocfs2_xattr_entry)); 4144 memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry)); 4145 } 4146 4147 /* 4148 * When the ocfs2_xattr_block is filled up, new bucket will be created 4149 * and all the xattr entries will be moved to the new bucket. 4150 * The header goes at the start of the bucket, and the names+values are 4151 * filled from the end. This is why *target starts as the last buffer. 4152 * Note: we need to sort the entries since they are not saved in order 4153 * in the ocfs2_xattr_block. 4154 */ 4155 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode, 4156 struct buffer_head *xb_bh, 4157 struct ocfs2_xattr_bucket *bucket) 4158 { 4159 int i, blocksize = inode->i_sb->s_blocksize; 4160 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4161 u16 offset, size, off_change; 4162 struct ocfs2_xattr_entry *xe; 4163 struct ocfs2_xattr_block *xb = 4164 (struct ocfs2_xattr_block *)xb_bh->b_data; 4165 struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header; 4166 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 4167 u16 count = le16_to_cpu(xb_xh->xh_count); 4168 char *src = xb_bh->b_data; 4169 char *target = bucket_block(bucket, blks - 1); 4170 4171 mlog(0, "cp xattr from block %llu to bucket %llu\n", 4172 (unsigned long long)xb_bh->b_blocknr, 4173 (unsigned long long)bucket_blkno(bucket)); 4174 4175 for (i = 0; i < blks; i++) 4176 memset(bucket_block(bucket, i), 0, blocksize); 4177 4178 /* 4179 * Since the xe_name_offset is based on ocfs2_xattr_header, 4180 * there is a offset change corresponding to the change of 4181 * ocfs2_xattr_header's position. 4182 */ 4183 off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 4184 xe = &xb_xh->xh_entries[count - 1]; 4185 offset = le16_to_cpu(xe->xe_name_offset) + off_change; 4186 size = blocksize - offset; 4187 4188 /* copy all the names and values. */ 4189 memcpy(target + offset, src + offset, size); 4190 4191 /* Init new header now. */ 4192 xh->xh_count = xb_xh->xh_count; 4193 xh->xh_num_buckets = cpu_to_le16(1); 4194 xh->xh_name_value_len = cpu_to_le16(size); 4195 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size); 4196 4197 /* copy all the entries. */ 4198 target = bucket_block(bucket, 0); 4199 offset = offsetof(struct ocfs2_xattr_header, xh_entries); 4200 size = count * sizeof(struct ocfs2_xattr_entry); 4201 memcpy(target + offset, (char *)xb_xh + offset, size); 4202 4203 /* Change the xe offset for all the xe because of the move. */ 4204 off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize + 4205 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 4206 for (i = 0; i < count; i++) 4207 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change); 4208 4209 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n", 4210 offset, size, off_change); 4211 4212 sort(target + offset, count, sizeof(struct ocfs2_xattr_entry), 4213 cmp_xe, swap_xe); 4214 } 4215 4216 /* 4217 * After we move xattr from block to index btree, we have to 4218 * update ocfs2_xattr_search to the new xe and base. 4219 * 4220 * When the entry is in xattr block, xattr_bh indicates the storage place. 4221 * While if the entry is in index b-tree, "bucket" indicates the 4222 * real place of the xattr. 4223 */ 4224 static void ocfs2_xattr_update_xattr_search(struct inode *inode, 4225 struct ocfs2_xattr_search *xs, 4226 struct buffer_head *old_bh) 4227 { 4228 char *buf = old_bh->b_data; 4229 struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf; 4230 struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header; 4231 int i; 4232 4233 xs->header = bucket_xh(xs->bucket); 4234 xs->base = bucket_block(xs->bucket, 0); 4235 xs->end = xs->base + inode->i_sb->s_blocksize; 4236 4237 if (xs->not_found) 4238 return; 4239 4240 i = xs->here - old_xh->xh_entries; 4241 xs->here = &xs->header->xh_entries[i]; 4242 } 4243 4244 static int ocfs2_xattr_create_index_block(struct inode *inode, 4245 struct ocfs2_xattr_search *xs, 4246 struct ocfs2_xattr_set_ctxt *ctxt) 4247 { 4248 int ret; 4249 u32 bit_off, len; 4250 u64 blkno; 4251 handle_t *handle = ctxt->handle; 4252 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4253 struct ocfs2_inode_info *oi = OCFS2_I(inode); 4254 struct buffer_head *xb_bh = xs->xattr_bh; 4255 struct ocfs2_xattr_block *xb = 4256 (struct ocfs2_xattr_block *)xb_bh->b_data; 4257 struct ocfs2_xattr_tree_root *xr; 4258 u16 xb_flags = le16_to_cpu(xb->xb_flags); 4259 4260 mlog(0, "create xattr index block for %llu\n", 4261 (unsigned long long)xb_bh->b_blocknr); 4262 4263 BUG_ON(xb_flags & OCFS2_XATTR_INDEXED); 4264 BUG_ON(!xs->bucket); 4265 4266 /* 4267 * XXX: 4268 * We can use this lock for now, and maybe move to a dedicated mutex 4269 * if performance becomes a problem later. 4270 */ 4271 down_write(&oi->ip_alloc_sem); 4272 4273 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), xb_bh, 4274 OCFS2_JOURNAL_ACCESS_WRITE); 4275 if (ret) { 4276 mlog_errno(ret); 4277 goto out; 4278 } 4279 4280 ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 4281 1, 1, &bit_off, &len); 4282 if (ret) { 4283 mlog_errno(ret); 4284 goto out; 4285 } 4286 4287 /* 4288 * The bucket may spread in many blocks, and 4289 * we will only touch the 1st block and the last block 4290 * in the whole bucket(one for entry and one for data). 4291 */ 4292 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); 4293 4294 mlog(0, "allocate 1 cluster from %llu to xattr block\n", 4295 (unsigned long long)blkno); 4296 4297 ret = ocfs2_init_xattr_bucket(xs->bucket, blkno); 4298 if (ret) { 4299 mlog_errno(ret); 4300 goto out; 4301 } 4302 4303 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket, 4304 OCFS2_JOURNAL_ACCESS_CREATE); 4305 if (ret) { 4306 mlog_errno(ret); 4307 goto out; 4308 } 4309 4310 ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket); 4311 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket); 4312 4313 ocfs2_xattr_update_xattr_search(inode, xs, xb_bh); 4314 4315 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */ 4316 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize - 4317 offsetof(struct ocfs2_xattr_block, xb_attrs)); 4318 4319 xr = &xb->xb_attrs.xb_root; 4320 xr->xt_clusters = cpu_to_le32(1); 4321 xr->xt_last_eb_blk = 0; 4322 xr->xt_list.l_tree_depth = 0; 4323 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb)); 4324 xr->xt_list.l_next_free_rec = cpu_to_le16(1); 4325 4326 xr->xt_list.l_recs[0].e_cpos = 0; 4327 xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno); 4328 xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1); 4329 4330 xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED); 4331 4332 ocfs2_journal_dirty(handle, xb_bh); 4333 4334 out: 4335 up_write(&oi->ip_alloc_sem); 4336 4337 return ret; 4338 } 4339 4340 static int cmp_xe_offset(const void *a, const void *b) 4341 { 4342 const struct ocfs2_xattr_entry *l = a, *r = b; 4343 u32 l_name_offset = le16_to_cpu(l->xe_name_offset); 4344 u32 r_name_offset = le16_to_cpu(r->xe_name_offset); 4345 4346 if (l_name_offset < r_name_offset) 4347 return 1; 4348 if (l_name_offset > r_name_offset) 4349 return -1; 4350 return 0; 4351 } 4352 4353 /* 4354 * defrag a xattr bucket if we find that the bucket has some 4355 * holes beteen name/value pairs. 4356 * We will move all the name/value pairs to the end of the bucket 4357 * so that we can spare some space for insertion. 4358 */ 4359 static int ocfs2_defrag_xattr_bucket(struct inode *inode, 4360 handle_t *handle, 4361 struct ocfs2_xattr_bucket *bucket) 4362 { 4363 int ret, i; 4364 size_t end, offset, len; 4365 struct ocfs2_xattr_header *xh; 4366 char *entries, *buf, *bucket_buf = NULL; 4367 u64 blkno = bucket_blkno(bucket); 4368 u16 xh_free_start; 4369 size_t blocksize = inode->i_sb->s_blocksize; 4370 struct ocfs2_xattr_entry *xe; 4371 4372 /* 4373 * In order to make the operation more efficient and generic, 4374 * we copy all the blocks into a contiguous memory and do the 4375 * defragment there, so if anything is error, we will not touch 4376 * the real block. 4377 */ 4378 bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS); 4379 if (!bucket_buf) { 4380 ret = -EIO; 4381 goto out; 4382 } 4383 4384 buf = bucket_buf; 4385 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize) 4386 memcpy(buf, bucket_block(bucket, i), blocksize); 4387 4388 ret = ocfs2_xattr_bucket_journal_access(handle, bucket, 4389 OCFS2_JOURNAL_ACCESS_WRITE); 4390 if (ret < 0) { 4391 mlog_errno(ret); 4392 goto out; 4393 } 4394 4395 xh = (struct ocfs2_xattr_header *)bucket_buf; 4396 entries = (char *)xh->xh_entries; 4397 xh_free_start = le16_to_cpu(xh->xh_free_start); 4398 4399 mlog(0, "adjust xattr bucket in %llu, count = %u, " 4400 "xh_free_start = %u, xh_name_value_len = %u.\n", 4401 (unsigned long long)blkno, le16_to_cpu(xh->xh_count), 4402 xh_free_start, le16_to_cpu(xh->xh_name_value_len)); 4403 4404 /* 4405 * sort all the entries by their offset. 4406 * the largest will be the first, so that we can 4407 * move them to the end one by one. 4408 */ 4409 sort(entries, le16_to_cpu(xh->xh_count), 4410 sizeof(struct ocfs2_xattr_entry), 4411 cmp_xe_offset, swap_xe); 4412 4413 /* Move all name/values to the end of the bucket. */ 4414 xe = xh->xh_entries; 4415 end = OCFS2_XATTR_BUCKET_SIZE; 4416 for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) { 4417 offset = le16_to_cpu(xe->xe_name_offset); 4418 len = namevalue_size_xe(xe); 4419 4420 /* 4421 * We must make sure that the name/value pair 4422 * exist in the same block. So adjust end to 4423 * the previous block end if needed. 4424 */ 4425 if (((end - len) / blocksize != 4426 (end - 1) / blocksize)) 4427 end = end - end % blocksize; 4428 4429 if (end > offset + len) { 4430 memmove(bucket_buf + end - len, 4431 bucket_buf + offset, len); 4432 xe->xe_name_offset = cpu_to_le16(end - len); 4433 } 4434 4435 mlog_bug_on_msg(end < offset + len, "Defrag check failed for " 4436 "bucket %llu\n", (unsigned long long)blkno); 4437 4438 end -= len; 4439 } 4440 4441 mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for " 4442 "bucket %llu\n", (unsigned long long)blkno); 4443 4444 if (xh_free_start == end) 4445 goto out; 4446 4447 memset(bucket_buf + xh_free_start, 0, end - xh_free_start); 4448 xh->xh_free_start = cpu_to_le16(end); 4449 4450 /* sort the entries by their name_hash. */ 4451 sort(entries, le16_to_cpu(xh->xh_count), 4452 sizeof(struct ocfs2_xattr_entry), 4453 cmp_xe, swap_xe); 4454 4455 buf = bucket_buf; 4456 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize) 4457 memcpy(bucket_block(bucket, i), buf, blocksize); 4458 ocfs2_xattr_bucket_journal_dirty(handle, bucket); 4459 4460 out: 4461 kfree(bucket_buf); 4462 return ret; 4463 } 4464 4465 /* 4466 * prev_blkno points to the start of an existing extent. new_blkno 4467 * points to a newly allocated extent. Because we know each of our 4468 * clusters contains more than bucket, we can easily split one cluster 4469 * at a bucket boundary. So we take the last cluster of the existing 4470 * extent and split it down the middle. We move the last half of the 4471 * buckets in the last cluster of the existing extent over to the new 4472 * extent. 4473 * 4474 * first_bh is the buffer at prev_blkno so we can update the existing 4475 * extent's bucket count. header_bh is the bucket were we were hoping 4476 * to insert our xattr. If the bucket move places the target in the new 4477 * extent, we'll update first_bh and header_bh after modifying the old 4478 * extent. 4479 * 4480 * first_hash will be set as the 1st xe's name_hash in the new extent. 4481 */ 4482 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode, 4483 handle_t *handle, 4484 struct ocfs2_xattr_bucket *first, 4485 struct ocfs2_xattr_bucket *target, 4486 u64 new_blkno, 4487 u32 num_clusters, 4488 u32 *first_hash) 4489 { 4490 int ret; 4491 struct super_block *sb = inode->i_sb; 4492 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb); 4493 int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb)); 4494 int to_move = num_buckets / 2; 4495 u64 src_blkno; 4496 u64 last_cluster_blkno = bucket_blkno(first) + 4497 ((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1)); 4498 4499 BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets); 4500 BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize); 4501 4502 mlog(0, "move half of xattrs in cluster %llu to %llu\n", 4503 (unsigned long long)last_cluster_blkno, (unsigned long long)new_blkno); 4504 4505 ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first), 4506 last_cluster_blkno, new_blkno, 4507 to_move, first_hash); 4508 if (ret) { 4509 mlog_errno(ret); 4510 goto out; 4511 } 4512 4513 /* This is the first bucket that got moved */ 4514 src_blkno = last_cluster_blkno + (to_move * blks_per_bucket); 4515 4516 /* 4517 * If the target bucket was part of the moved buckets, we need to 4518 * update first and target. 4519 */ 4520 if (bucket_blkno(target) >= src_blkno) { 4521 /* Find the block for the new target bucket */ 4522 src_blkno = new_blkno + 4523 (bucket_blkno(target) - src_blkno); 4524 4525 ocfs2_xattr_bucket_relse(first); 4526 ocfs2_xattr_bucket_relse(target); 4527 4528 /* 4529 * These shouldn't fail - the buffers are in the 4530 * journal from ocfs2_cp_xattr_bucket(). 4531 */ 4532 ret = ocfs2_read_xattr_bucket(first, new_blkno); 4533 if (ret) { 4534 mlog_errno(ret); 4535 goto out; 4536 } 4537 ret = ocfs2_read_xattr_bucket(target, src_blkno); 4538 if (ret) 4539 mlog_errno(ret); 4540 4541 } 4542 4543 out: 4544 return ret; 4545 } 4546 4547 /* 4548 * Find the suitable pos when we divide a bucket into 2. 4549 * We have to make sure the xattrs with the same hash value exist 4550 * in the same bucket. 4551 * 4552 * If this ocfs2_xattr_header covers more than one hash value, find a 4553 * place where the hash value changes. Try to find the most even split. 4554 * The most common case is that all entries have different hash values, 4555 * and the first check we make will find a place to split. 4556 */ 4557 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header *xh) 4558 { 4559 struct ocfs2_xattr_entry *entries = xh->xh_entries; 4560 int count = le16_to_cpu(xh->xh_count); 4561 int delta, middle = count / 2; 4562 4563 /* 4564 * We start at the middle. Each step gets farther away in both 4565 * directions. We therefore hit the change in hash value 4566 * nearest to the middle. Note that this loop does not execute for 4567 * count < 2. 4568 */ 4569 for (delta = 0; delta < middle; delta++) { 4570 /* Let's check delta earlier than middle */ 4571 if (cmp_xe(&entries[middle - delta - 1], 4572 &entries[middle - delta])) 4573 return middle - delta; 4574 4575 /* For even counts, don't walk off the end */ 4576 if ((middle + delta + 1) == count) 4577 continue; 4578 4579 /* Now try delta past middle */ 4580 if (cmp_xe(&entries[middle + delta], 4581 &entries[middle + delta + 1])) 4582 return middle + delta + 1; 4583 } 4584 4585 /* Every entry had the same hash */ 4586 return count; 4587 } 4588 4589 /* 4590 * Move some xattrs in old bucket(blk) to new bucket(new_blk). 4591 * first_hash will record the 1st hash of the new bucket. 4592 * 4593 * Normally half of the xattrs will be moved. But we have to make 4594 * sure that the xattrs with the same hash value are stored in the 4595 * same bucket. If all the xattrs in this bucket have the same hash 4596 * value, the new bucket will be initialized as an empty one and the 4597 * first_hash will be initialized as (hash_value+1). 4598 */ 4599 static int ocfs2_divide_xattr_bucket(struct inode *inode, 4600 handle_t *handle, 4601 u64 blk, 4602 u64 new_blk, 4603 u32 *first_hash, 4604 int new_bucket_head) 4605 { 4606 int ret, i; 4607 int count, start, len, name_value_len = 0, name_offset = 0; 4608 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL; 4609 struct ocfs2_xattr_header *xh; 4610 struct ocfs2_xattr_entry *xe; 4611 int blocksize = inode->i_sb->s_blocksize; 4612 4613 mlog(0, "move some of xattrs from bucket %llu to %llu\n", 4614 (unsigned long long)blk, (unsigned long long)new_blk); 4615 4616 s_bucket = ocfs2_xattr_bucket_new(inode); 4617 t_bucket = ocfs2_xattr_bucket_new(inode); 4618 if (!s_bucket || !t_bucket) { 4619 ret = -ENOMEM; 4620 mlog_errno(ret); 4621 goto out; 4622 } 4623 4624 ret = ocfs2_read_xattr_bucket(s_bucket, blk); 4625 if (ret) { 4626 mlog_errno(ret); 4627 goto out; 4628 } 4629 4630 ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket, 4631 OCFS2_JOURNAL_ACCESS_WRITE); 4632 if (ret) { 4633 mlog_errno(ret); 4634 goto out; 4635 } 4636 4637 /* 4638 * Even if !new_bucket_head, we're overwriting t_bucket. Thus, 4639 * there's no need to read it. 4640 */ 4641 ret = ocfs2_init_xattr_bucket(t_bucket, new_blk); 4642 if (ret) { 4643 mlog_errno(ret); 4644 goto out; 4645 } 4646 4647 /* 4648 * Hey, if we're overwriting t_bucket, what difference does 4649 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the 4650 * same part of ocfs2_cp_xattr_bucket(). 4651 */ 4652 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket, 4653 new_bucket_head ? 4654 OCFS2_JOURNAL_ACCESS_CREATE : 4655 OCFS2_JOURNAL_ACCESS_WRITE); 4656 if (ret) { 4657 mlog_errno(ret); 4658 goto out; 4659 } 4660 4661 xh = bucket_xh(s_bucket); 4662 count = le16_to_cpu(xh->xh_count); 4663 start = ocfs2_xattr_find_divide_pos(xh); 4664 4665 if (start == count) { 4666 xe = &xh->xh_entries[start-1]; 4667 4668 /* 4669 * initialized a new empty bucket here. 4670 * The hash value is set as one larger than 4671 * that of the last entry in the previous bucket. 4672 */ 4673 for (i = 0; i < t_bucket->bu_blocks; i++) 4674 memset(bucket_block(t_bucket, i), 0, blocksize); 4675 4676 xh = bucket_xh(t_bucket); 4677 xh->xh_free_start = cpu_to_le16(blocksize); 4678 xh->xh_entries[0].xe_name_hash = xe->xe_name_hash; 4679 le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1); 4680 4681 goto set_num_buckets; 4682 } 4683 4684 /* copy the whole bucket to the new first. */ 4685 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket); 4686 4687 /* update the new bucket. */ 4688 xh = bucket_xh(t_bucket); 4689 4690 /* 4691 * Calculate the total name/value len and xh_free_start for 4692 * the old bucket first. 4693 */ 4694 name_offset = OCFS2_XATTR_BUCKET_SIZE; 4695 name_value_len = 0; 4696 for (i = 0; i < start; i++) { 4697 xe = &xh->xh_entries[i]; 4698 name_value_len += namevalue_size_xe(xe); 4699 if (le16_to_cpu(xe->xe_name_offset) < name_offset) 4700 name_offset = le16_to_cpu(xe->xe_name_offset); 4701 } 4702 4703 /* 4704 * Now begin the modification to the new bucket. 4705 * 4706 * In the new bucket, We just move the xattr entry to the beginning 4707 * and don't touch the name/value. So there will be some holes in the 4708 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is 4709 * called. 4710 */ 4711 xe = &xh->xh_entries[start]; 4712 len = sizeof(struct ocfs2_xattr_entry) * (count - start); 4713 mlog(0, "mv xattr entry len %d from %d to %d\n", len, 4714 (int)((char *)xe - (char *)xh), 4715 (int)((char *)xh->xh_entries - (char *)xh)); 4716 memmove((char *)xh->xh_entries, (char *)xe, len); 4717 xe = &xh->xh_entries[count - start]; 4718 len = sizeof(struct ocfs2_xattr_entry) * start; 4719 memset((char *)xe, 0, len); 4720 4721 le16_add_cpu(&xh->xh_count, -start); 4722 le16_add_cpu(&xh->xh_name_value_len, -name_value_len); 4723 4724 /* Calculate xh_free_start for the new bucket. */ 4725 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE); 4726 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 4727 xe = &xh->xh_entries[i]; 4728 if (le16_to_cpu(xe->xe_name_offset) < 4729 le16_to_cpu(xh->xh_free_start)) 4730 xh->xh_free_start = xe->xe_name_offset; 4731 } 4732 4733 set_num_buckets: 4734 /* set xh->xh_num_buckets for the new xh. */ 4735 if (new_bucket_head) 4736 xh->xh_num_buckets = cpu_to_le16(1); 4737 else 4738 xh->xh_num_buckets = 0; 4739 4740 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket); 4741 4742 /* store the first_hash of the new bucket. */ 4743 if (first_hash) 4744 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash); 4745 4746 /* 4747 * Now only update the 1st block of the old bucket. If we 4748 * just added a new empty bucket, there is no need to modify 4749 * it. 4750 */ 4751 if (start == count) 4752 goto out; 4753 4754 xh = bucket_xh(s_bucket); 4755 memset(&xh->xh_entries[start], 0, 4756 sizeof(struct ocfs2_xattr_entry) * (count - start)); 4757 xh->xh_count = cpu_to_le16(start); 4758 xh->xh_free_start = cpu_to_le16(name_offset); 4759 xh->xh_name_value_len = cpu_to_le16(name_value_len); 4760 4761 ocfs2_xattr_bucket_journal_dirty(handle, s_bucket); 4762 4763 out: 4764 ocfs2_xattr_bucket_free(s_bucket); 4765 ocfs2_xattr_bucket_free(t_bucket); 4766 4767 return ret; 4768 } 4769 4770 /* 4771 * Copy xattr from one bucket to another bucket. 4772 * 4773 * The caller must make sure that the journal transaction 4774 * has enough space for journaling. 4775 */ 4776 static int ocfs2_cp_xattr_bucket(struct inode *inode, 4777 handle_t *handle, 4778 u64 s_blkno, 4779 u64 t_blkno, 4780 int t_is_new) 4781 { 4782 int ret; 4783 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL; 4784 4785 BUG_ON(s_blkno == t_blkno); 4786 4787 mlog(0, "cp bucket %llu to %llu, target is %d\n", 4788 (unsigned long long)s_blkno, (unsigned long long)t_blkno, 4789 t_is_new); 4790 4791 s_bucket = ocfs2_xattr_bucket_new(inode); 4792 t_bucket = ocfs2_xattr_bucket_new(inode); 4793 if (!s_bucket || !t_bucket) { 4794 ret = -ENOMEM; 4795 mlog_errno(ret); 4796 goto out; 4797 } 4798 4799 ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno); 4800 if (ret) 4801 goto out; 4802 4803 /* 4804 * Even if !t_is_new, we're overwriting t_bucket. Thus, 4805 * there's no need to read it. 4806 */ 4807 ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno); 4808 if (ret) 4809 goto out; 4810 4811 /* 4812 * Hey, if we're overwriting t_bucket, what difference does 4813 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new 4814 * cluster to fill, we came here from 4815 * ocfs2_mv_xattr_buckets(), and it is really new - 4816 * ACCESS_CREATE is required. But we also might have moved data 4817 * out of t_bucket before extending back into it. 4818 * ocfs2_add_new_xattr_bucket() can do this - its call to 4819 * ocfs2_add_new_xattr_cluster() may have created a new extent 4820 * and copied out the end of the old extent. Then it re-extends 4821 * the old extent back to create space for new xattrs. That's 4822 * how we get here, and the bucket isn't really new. 4823 */ 4824 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket, 4825 t_is_new ? 4826 OCFS2_JOURNAL_ACCESS_CREATE : 4827 OCFS2_JOURNAL_ACCESS_WRITE); 4828 if (ret) 4829 goto out; 4830 4831 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket); 4832 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket); 4833 4834 out: 4835 ocfs2_xattr_bucket_free(t_bucket); 4836 ocfs2_xattr_bucket_free(s_bucket); 4837 4838 return ret; 4839 } 4840 4841 /* 4842 * src_blk points to the start of an existing extent. last_blk points to 4843 * last cluster in that extent. to_blk points to a newly allocated 4844 * extent. We copy the buckets from the cluster at last_blk to the new 4845 * extent. If start_bucket is non-zero, we skip that many buckets before 4846 * we start copying. The new extent's xh_num_buckets gets set to the 4847 * number of buckets we copied. The old extent's xh_num_buckets shrinks 4848 * by the same amount. 4849 */ 4850 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle, 4851 u64 src_blk, u64 last_blk, u64 to_blk, 4852 unsigned int start_bucket, 4853 u32 *first_hash) 4854 { 4855 int i, ret, credits; 4856 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4857 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4858 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb); 4859 struct ocfs2_xattr_bucket *old_first, *new_first; 4860 4861 mlog(0, "mv xattrs from cluster %llu to %llu\n", 4862 (unsigned long long)last_blk, (unsigned long long)to_blk); 4863 4864 BUG_ON(start_bucket >= num_buckets); 4865 if (start_bucket) { 4866 num_buckets -= start_bucket; 4867 last_blk += (start_bucket * blks_per_bucket); 4868 } 4869 4870 /* The first bucket of the original extent */ 4871 old_first = ocfs2_xattr_bucket_new(inode); 4872 /* The first bucket of the new extent */ 4873 new_first = ocfs2_xattr_bucket_new(inode); 4874 if (!old_first || !new_first) { 4875 ret = -ENOMEM; 4876 mlog_errno(ret); 4877 goto out; 4878 } 4879 4880 ret = ocfs2_read_xattr_bucket(old_first, src_blk); 4881 if (ret) { 4882 mlog_errno(ret); 4883 goto out; 4884 } 4885 4886 /* 4887 * We need to update the first bucket of the old extent and all 4888 * the buckets going to the new extent. 4889 */ 4890 credits = ((num_buckets + 1) * blks_per_bucket) + 4891 handle->h_buffer_credits; 4892 ret = ocfs2_extend_trans(handle, credits); 4893 if (ret) { 4894 mlog_errno(ret); 4895 goto out; 4896 } 4897 4898 ret = ocfs2_xattr_bucket_journal_access(handle, old_first, 4899 OCFS2_JOURNAL_ACCESS_WRITE); 4900 if (ret) { 4901 mlog_errno(ret); 4902 goto out; 4903 } 4904 4905 for (i = 0; i < num_buckets; i++) { 4906 ret = ocfs2_cp_xattr_bucket(inode, handle, 4907 last_blk + (i * blks_per_bucket), 4908 to_blk + (i * blks_per_bucket), 4909 1); 4910 if (ret) { 4911 mlog_errno(ret); 4912 goto out; 4913 } 4914 } 4915 4916 /* 4917 * Get the new bucket ready before we dirty anything 4918 * (This actually shouldn't fail, because we already dirtied 4919 * it once in ocfs2_cp_xattr_bucket()). 4920 */ 4921 ret = ocfs2_read_xattr_bucket(new_first, to_blk); 4922 if (ret) { 4923 mlog_errno(ret); 4924 goto out; 4925 } 4926 ret = ocfs2_xattr_bucket_journal_access(handle, new_first, 4927 OCFS2_JOURNAL_ACCESS_WRITE); 4928 if (ret) { 4929 mlog_errno(ret); 4930 goto out; 4931 } 4932 4933 /* Now update the headers */ 4934 le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets); 4935 ocfs2_xattr_bucket_journal_dirty(handle, old_first); 4936 4937 bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets); 4938 ocfs2_xattr_bucket_journal_dirty(handle, new_first); 4939 4940 if (first_hash) 4941 *first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash); 4942 4943 out: 4944 ocfs2_xattr_bucket_free(new_first); 4945 ocfs2_xattr_bucket_free(old_first); 4946 return ret; 4947 } 4948 4949 /* 4950 * Move some xattrs in this cluster to the new cluster. 4951 * This function should only be called when bucket size == cluster size. 4952 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead. 4953 */ 4954 static int ocfs2_divide_xattr_cluster(struct inode *inode, 4955 handle_t *handle, 4956 u64 prev_blk, 4957 u64 new_blk, 4958 u32 *first_hash) 4959 { 4960 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4961 int ret, credits = 2 * blk_per_bucket + handle->h_buffer_credits; 4962 4963 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize); 4964 4965 ret = ocfs2_extend_trans(handle, credits); 4966 if (ret) { 4967 mlog_errno(ret); 4968 return ret; 4969 } 4970 4971 /* Move half of the xattr in start_blk to the next bucket. */ 4972 return ocfs2_divide_xattr_bucket(inode, handle, prev_blk, 4973 new_blk, first_hash, 1); 4974 } 4975 4976 /* 4977 * Move some xattrs from the old cluster to the new one since they are not 4978 * contiguous in ocfs2 xattr tree. 4979 * 4980 * new_blk starts a new separate cluster, and we will move some xattrs from 4981 * prev_blk to it. v_start will be set as the first name hash value in this 4982 * new cluster so that it can be used as e_cpos during tree insertion and 4983 * don't collide with our original b-tree operations. first_bh and header_bh 4984 * will also be updated since they will be used in ocfs2_extend_xattr_bucket 4985 * to extend the insert bucket. 4986 * 4987 * The problem is how much xattr should we move to the new one and when should 4988 * we update first_bh and header_bh? 4989 * 1. If cluster size > bucket size, that means the previous cluster has more 4990 * than 1 bucket, so just move half nums of bucket into the new cluster and 4991 * update the first_bh and header_bh if the insert bucket has been moved 4992 * to the new cluster. 4993 * 2. If cluster_size == bucket_size: 4994 * a) If the previous extent rec has more than one cluster and the insert 4995 * place isn't in the last cluster, copy the entire last cluster to the 4996 * new one. This time, we don't need to upate the first_bh and header_bh 4997 * since they will not be moved into the new cluster. 4998 * b) Otherwise, move the bottom half of the xattrs in the last cluster into 4999 * the new one. And we set the extend flag to zero if the insert place is 5000 * moved into the new allocated cluster since no extend is needed. 5001 */ 5002 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode, 5003 handle_t *handle, 5004 struct ocfs2_xattr_bucket *first, 5005 struct ocfs2_xattr_bucket *target, 5006 u64 new_blk, 5007 u32 prev_clusters, 5008 u32 *v_start, 5009 int *extend) 5010 { 5011 int ret; 5012 5013 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n", 5014 (unsigned long long)bucket_blkno(first), prev_clusters, 5015 (unsigned long long)new_blk); 5016 5017 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) { 5018 ret = ocfs2_mv_xattr_bucket_cross_cluster(inode, 5019 handle, 5020 first, target, 5021 new_blk, 5022 prev_clusters, 5023 v_start); 5024 if (ret) 5025 mlog_errno(ret); 5026 } else { 5027 /* The start of the last cluster in the first extent */ 5028 u64 last_blk = bucket_blkno(first) + 5029 ((prev_clusters - 1) * 5030 ocfs2_clusters_to_blocks(inode->i_sb, 1)); 5031 5032 if (prev_clusters > 1 && bucket_blkno(target) != last_blk) { 5033 ret = ocfs2_mv_xattr_buckets(inode, handle, 5034 bucket_blkno(first), 5035 last_blk, new_blk, 0, 5036 v_start); 5037 if (ret) 5038 mlog_errno(ret); 5039 } else { 5040 ret = ocfs2_divide_xattr_cluster(inode, handle, 5041 last_blk, new_blk, 5042 v_start); 5043 if (ret) 5044 mlog_errno(ret); 5045 5046 if ((bucket_blkno(target) == last_blk) && extend) 5047 *extend = 0; 5048 } 5049 } 5050 5051 return ret; 5052 } 5053 5054 /* 5055 * Add a new cluster for xattr storage. 5056 * 5057 * If the new cluster is contiguous with the previous one, it will be 5058 * appended to the same extent record, and num_clusters will be updated. 5059 * If not, we will insert a new extent for it and move some xattrs in 5060 * the last cluster into the new allocated one. 5061 * We also need to limit the maximum size of a btree leaf, otherwise we'll 5062 * lose the benefits of hashing because we'll have to search large leaves. 5063 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize, 5064 * if it's bigger). 5065 * 5066 * first_bh is the first block of the previous extent rec and header_bh 5067 * indicates the bucket we will insert the new xattrs. They will be updated 5068 * when the header_bh is moved into the new cluster. 5069 */ 5070 static int ocfs2_add_new_xattr_cluster(struct inode *inode, 5071 struct buffer_head *root_bh, 5072 struct ocfs2_xattr_bucket *first, 5073 struct ocfs2_xattr_bucket *target, 5074 u32 *num_clusters, 5075 u32 prev_cpos, 5076 int *extend, 5077 struct ocfs2_xattr_set_ctxt *ctxt) 5078 { 5079 int ret; 5080 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 5081 u32 prev_clusters = *num_clusters; 5082 u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0; 5083 u64 block; 5084 handle_t *handle = ctxt->handle; 5085 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5086 struct ocfs2_extent_tree et; 5087 5088 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, " 5089 "previous xattr blkno = %llu\n", 5090 (unsigned long long)OCFS2_I(inode)->ip_blkno, 5091 prev_cpos, (unsigned long long)bucket_blkno(first)); 5092 5093 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh); 5094 5095 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh, 5096 OCFS2_JOURNAL_ACCESS_WRITE); 5097 if (ret < 0) { 5098 mlog_errno(ret); 5099 goto leave; 5100 } 5101 5102 ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 1, 5103 clusters_to_add, &bit_off, &num_bits); 5104 if (ret < 0) { 5105 if (ret != -ENOSPC) 5106 mlog_errno(ret); 5107 goto leave; 5108 } 5109 5110 BUG_ON(num_bits > clusters_to_add); 5111 5112 block = ocfs2_clusters_to_blocks(osb->sb, bit_off); 5113 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n", 5114 num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno); 5115 5116 if (bucket_blkno(first) + (prev_clusters * bpc) == block && 5117 (prev_clusters + num_bits) << osb->s_clustersize_bits <= 5118 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) { 5119 /* 5120 * If this cluster is contiguous with the old one and 5121 * adding this new cluster, we don't surpass the limit of 5122 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be 5123 * initialized and used like other buckets in the previous 5124 * cluster. 5125 * So add it as a contiguous one. The caller will handle 5126 * its init process. 5127 */ 5128 v_start = prev_cpos + prev_clusters; 5129 *num_clusters = prev_clusters + num_bits; 5130 mlog(0, "Add contiguous %u clusters to previous extent rec.\n", 5131 num_bits); 5132 } else { 5133 ret = ocfs2_adjust_xattr_cross_cluster(inode, 5134 handle, 5135 first, 5136 target, 5137 block, 5138 prev_clusters, 5139 &v_start, 5140 extend); 5141 if (ret) { 5142 mlog_errno(ret); 5143 goto leave; 5144 } 5145 } 5146 5147 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n", 5148 num_bits, (unsigned long long)block, v_start); 5149 ret = ocfs2_insert_extent(handle, &et, v_start, block, 5150 num_bits, 0, ctxt->meta_ac); 5151 if (ret < 0) { 5152 mlog_errno(ret); 5153 goto leave; 5154 } 5155 5156 ret = ocfs2_journal_dirty(handle, root_bh); 5157 if (ret < 0) 5158 mlog_errno(ret); 5159 5160 leave: 5161 return ret; 5162 } 5163 5164 /* 5165 * We are given an extent. 'first' is the bucket at the very front of 5166 * the extent. The extent has space for an additional bucket past 5167 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number 5168 * of the target bucket. We wish to shift every bucket past the target 5169 * down one, filling in that additional space. When we get back to the 5170 * target, we split the target between itself and the now-empty bucket 5171 * at target+1 (aka, target_blkno + blks_per_bucket). 5172 */ 5173 static int ocfs2_extend_xattr_bucket(struct inode *inode, 5174 handle_t *handle, 5175 struct ocfs2_xattr_bucket *first, 5176 u64 target_blk, 5177 u32 num_clusters) 5178 { 5179 int ret, credits; 5180 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5181 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 5182 u64 end_blk; 5183 u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets); 5184 5185 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting " 5186 "from %llu, len = %u\n", (unsigned long long)target_blk, 5187 (unsigned long long)bucket_blkno(first), num_clusters); 5188 5189 /* The extent must have room for an additional bucket */ 5190 BUG_ON(new_bucket >= 5191 (num_clusters * ocfs2_xattr_buckets_per_cluster(osb))); 5192 5193 /* end_blk points to the last existing bucket */ 5194 end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket); 5195 5196 /* 5197 * end_blk is the start of the last existing bucket. 5198 * Thus, (end_blk - target_blk) covers the target bucket and 5199 * every bucket after it up to, but not including, the last 5200 * existing bucket. Then we add the last existing bucket, the 5201 * new bucket, and the first bucket (3 * blk_per_bucket). 5202 */ 5203 credits = (end_blk - target_blk) + (3 * blk_per_bucket) + 5204 handle->h_buffer_credits; 5205 ret = ocfs2_extend_trans(handle, credits); 5206 if (ret) { 5207 mlog_errno(ret); 5208 goto out; 5209 } 5210 5211 ret = ocfs2_xattr_bucket_journal_access(handle, first, 5212 OCFS2_JOURNAL_ACCESS_WRITE); 5213 if (ret) { 5214 mlog_errno(ret); 5215 goto out; 5216 } 5217 5218 while (end_blk != target_blk) { 5219 ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk, 5220 end_blk + blk_per_bucket, 0); 5221 if (ret) 5222 goto out; 5223 end_blk -= blk_per_bucket; 5224 } 5225 5226 /* Move half of the xattr in target_blkno to the next bucket. */ 5227 ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk, 5228 target_blk + blk_per_bucket, NULL, 0); 5229 5230 le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1); 5231 ocfs2_xattr_bucket_journal_dirty(handle, first); 5232 5233 out: 5234 return ret; 5235 } 5236 5237 /* 5238 * Add new xattr bucket in an extent record and adjust the buckets 5239 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the 5240 * bucket we want to insert into. 5241 * 5242 * In the easy case, we will move all the buckets after target down by 5243 * one. Half of target's xattrs will be moved to the next bucket. 5244 * 5245 * If current cluster is full, we'll allocate a new one. This may not 5246 * be contiguous. The underlying calls will make sure that there is 5247 * space for the insert, shifting buckets around if necessary. 5248 * 'target' may be moved by those calls. 5249 */ 5250 static int ocfs2_add_new_xattr_bucket(struct inode *inode, 5251 struct buffer_head *xb_bh, 5252 struct ocfs2_xattr_bucket *target, 5253 struct ocfs2_xattr_set_ctxt *ctxt) 5254 { 5255 struct ocfs2_xattr_block *xb = 5256 (struct ocfs2_xattr_block *)xb_bh->b_data; 5257 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root; 5258 struct ocfs2_extent_list *el = &xb_root->xt_list; 5259 u32 name_hash = 5260 le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash); 5261 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5262 int ret, num_buckets, extend = 1; 5263 u64 p_blkno; 5264 u32 e_cpos, num_clusters; 5265 /* The bucket at the front of the extent */ 5266 struct ocfs2_xattr_bucket *first; 5267 5268 mlog(0, "Add new xattr bucket starting from %llu\n", 5269 (unsigned long long)bucket_blkno(target)); 5270 5271 /* The first bucket of the original extent */ 5272 first = ocfs2_xattr_bucket_new(inode); 5273 if (!first) { 5274 ret = -ENOMEM; 5275 mlog_errno(ret); 5276 goto out; 5277 } 5278 5279 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos, 5280 &num_clusters, el); 5281 if (ret) { 5282 mlog_errno(ret); 5283 goto out; 5284 } 5285 5286 ret = ocfs2_read_xattr_bucket(first, p_blkno); 5287 if (ret) { 5288 mlog_errno(ret); 5289 goto out; 5290 } 5291 5292 num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters; 5293 if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) { 5294 /* 5295 * This can move first+target if the target bucket moves 5296 * to the new extent. 5297 */ 5298 ret = ocfs2_add_new_xattr_cluster(inode, 5299 xb_bh, 5300 first, 5301 target, 5302 &num_clusters, 5303 e_cpos, 5304 &extend, 5305 ctxt); 5306 if (ret) { 5307 mlog_errno(ret); 5308 goto out; 5309 } 5310 } 5311 5312 if (extend) { 5313 ret = ocfs2_extend_xattr_bucket(inode, 5314 ctxt->handle, 5315 first, 5316 bucket_blkno(target), 5317 num_clusters); 5318 if (ret) 5319 mlog_errno(ret); 5320 } 5321 5322 out: 5323 ocfs2_xattr_bucket_free(first); 5324 5325 return ret; 5326 } 5327 5328 static inline char *ocfs2_xattr_bucket_get_val(struct inode *inode, 5329 struct ocfs2_xattr_bucket *bucket, 5330 int offs) 5331 { 5332 int block_off = offs >> inode->i_sb->s_blocksize_bits; 5333 5334 offs = offs % inode->i_sb->s_blocksize; 5335 return bucket_block(bucket, block_off) + offs; 5336 } 5337 5338 /* 5339 * Truncate the specified xe_off entry in xattr bucket. 5340 * bucket is indicated by header_bh and len is the new length. 5341 * Both the ocfs2_xattr_value_root and the entry will be updated here. 5342 * 5343 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed. 5344 */ 5345 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode, 5346 struct ocfs2_xattr_bucket *bucket, 5347 int xe_off, 5348 int len, 5349 struct ocfs2_xattr_set_ctxt *ctxt) 5350 { 5351 int ret, offset; 5352 u64 value_blk; 5353 struct ocfs2_xattr_entry *xe; 5354 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5355 size_t blocksize = inode->i_sb->s_blocksize; 5356 struct ocfs2_xattr_value_buf vb = { 5357 .vb_access = ocfs2_journal_access, 5358 }; 5359 5360 xe = &xh->xh_entries[xe_off]; 5361 5362 BUG_ON(!xe || ocfs2_xattr_is_local(xe)); 5363 5364 offset = le16_to_cpu(xe->xe_name_offset) + 5365 OCFS2_XATTR_SIZE(xe->xe_name_len); 5366 5367 value_blk = offset / blocksize; 5368 5369 /* We don't allow ocfs2_xattr_value to be stored in different block. */ 5370 BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize); 5371 5372 vb.vb_bh = bucket->bu_bhs[value_blk]; 5373 BUG_ON(!vb.vb_bh); 5374 5375 vb.vb_xv = (struct ocfs2_xattr_value_root *) 5376 (vb.vb_bh->b_data + offset % blocksize); 5377 5378 /* 5379 * From here on out we have to dirty the bucket. The generic 5380 * value calls only modify one of the bucket's bhs, but we need 5381 * to send the bucket at once. So if they error, they *could* have 5382 * modified something. We have to assume they did, and dirty 5383 * the whole bucket. This leaves us in a consistent state. 5384 */ 5385 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n", 5386 xe_off, (unsigned long long)bucket_blkno(bucket), len); 5387 ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt); 5388 if (ret) { 5389 mlog_errno(ret); 5390 goto out; 5391 } 5392 5393 ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket, 5394 OCFS2_JOURNAL_ACCESS_WRITE); 5395 if (ret) { 5396 mlog_errno(ret); 5397 goto out; 5398 } 5399 5400 xe->xe_value_size = cpu_to_le64(len); 5401 5402 ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket); 5403 5404 out: 5405 return ret; 5406 } 5407 5408 static int ocfs2_rm_xattr_cluster(struct inode *inode, 5409 struct buffer_head *root_bh, 5410 u64 blkno, 5411 u32 cpos, 5412 u32 len, 5413 void *para) 5414 { 5415 int ret; 5416 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5417 struct inode *tl_inode = osb->osb_tl_inode; 5418 handle_t *handle; 5419 struct ocfs2_xattr_block *xb = 5420 (struct ocfs2_xattr_block *)root_bh->b_data; 5421 struct ocfs2_alloc_context *meta_ac = NULL; 5422 struct ocfs2_cached_dealloc_ctxt dealloc; 5423 struct ocfs2_extent_tree et; 5424 5425 ret = ocfs2_iterate_xattr_buckets(inode, blkno, len, 5426 ocfs2_delete_xattr_in_bucket, para); 5427 if (ret) { 5428 mlog_errno(ret); 5429 return ret; 5430 } 5431 5432 ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh); 5433 5434 ocfs2_init_dealloc_ctxt(&dealloc); 5435 5436 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n", 5437 cpos, len, (unsigned long long)blkno); 5438 5439 ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), blkno, 5440 len); 5441 5442 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac); 5443 if (ret) { 5444 mlog_errno(ret); 5445 return ret; 5446 } 5447 5448 mutex_lock(&tl_inode->i_mutex); 5449 5450 if (ocfs2_truncate_log_needs_flush(osb)) { 5451 ret = __ocfs2_flush_truncate_log(osb); 5452 if (ret < 0) { 5453 mlog_errno(ret); 5454 goto out; 5455 } 5456 } 5457 5458 handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb)); 5459 if (IS_ERR(handle)) { 5460 ret = -ENOMEM; 5461 mlog_errno(ret); 5462 goto out; 5463 } 5464 5465 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh, 5466 OCFS2_JOURNAL_ACCESS_WRITE); 5467 if (ret) { 5468 mlog_errno(ret); 5469 goto out_commit; 5470 } 5471 5472 ret = ocfs2_remove_extent(handle, &et, cpos, len, meta_ac, 5473 &dealloc); 5474 if (ret) { 5475 mlog_errno(ret); 5476 goto out_commit; 5477 } 5478 5479 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len); 5480 5481 ret = ocfs2_journal_dirty(handle, root_bh); 5482 if (ret) { 5483 mlog_errno(ret); 5484 goto out_commit; 5485 } 5486 5487 ret = ocfs2_truncate_log_append(osb, handle, blkno, len); 5488 if (ret) 5489 mlog_errno(ret); 5490 5491 out_commit: 5492 ocfs2_commit_trans(osb, handle); 5493 out: 5494 ocfs2_schedule_truncate_log_flush(osb, 1); 5495 5496 mutex_unlock(&tl_inode->i_mutex); 5497 5498 if (meta_ac) 5499 ocfs2_free_alloc_context(meta_ac); 5500 5501 ocfs2_run_deallocs(osb, &dealloc); 5502 5503 return ret; 5504 } 5505 5506 /* 5507 * check whether the xattr bucket is filled up with the same hash value. 5508 * If we want to insert the xattr with the same hash, return -ENOSPC. 5509 * If we want to insert a xattr with different hash value, go ahead 5510 * and ocfs2_divide_xattr_bucket will handle this. 5511 */ 5512 static int ocfs2_check_xattr_bucket_collision(struct inode *inode, 5513 struct ocfs2_xattr_bucket *bucket, 5514 const char *name) 5515 { 5516 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5517 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name)); 5518 5519 if (name_hash != le32_to_cpu(xh->xh_entries[0].xe_name_hash)) 5520 return 0; 5521 5522 if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash == 5523 xh->xh_entries[0].xe_name_hash) { 5524 mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, " 5525 "hash = %u\n", 5526 (unsigned long long)bucket_blkno(bucket), 5527 le32_to_cpu(xh->xh_entries[0].xe_name_hash)); 5528 return -ENOSPC; 5529 } 5530 5531 return 0; 5532 } 5533 5534 /* 5535 * Try to set the entry in the current bucket. If we fail, the caller 5536 * will handle getting us another bucket. 5537 */ 5538 static int ocfs2_xattr_set_entry_bucket(struct inode *inode, 5539 struct ocfs2_xattr_info *xi, 5540 struct ocfs2_xattr_search *xs, 5541 struct ocfs2_xattr_set_ctxt *ctxt) 5542 { 5543 int ret; 5544 struct ocfs2_xa_loc loc; 5545 5546 mlog_entry("Set xattr %s in xattr bucket\n", xi->xi_name); 5547 5548 ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket, 5549 xs->not_found ? NULL : xs->here); 5550 ret = ocfs2_xa_set(&loc, xi, ctxt); 5551 if (!ret) { 5552 xs->here = loc.xl_entry; 5553 goto out; 5554 } 5555 if (ret != -ENOSPC) { 5556 mlog_errno(ret); 5557 goto out; 5558 } 5559 5560 /* Ok, we need space. Let's try defragmenting the bucket. */ 5561 ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle, 5562 xs->bucket); 5563 if (ret) { 5564 mlog_errno(ret); 5565 goto out; 5566 } 5567 5568 ret = ocfs2_xa_set(&loc, xi, ctxt); 5569 if (!ret) { 5570 xs->here = loc.xl_entry; 5571 goto out; 5572 } 5573 if (ret != -ENOSPC) 5574 mlog_errno(ret); 5575 5576 5577 out: 5578 mlog_exit(ret); 5579 return ret; 5580 } 5581 5582 static int ocfs2_xattr_set_entry_index_block(struct inode *inode, 5583 struct ocfs2_xattr_info *xi, 5584 struct ocfs2_xattr_search *xs, 5585 struct ocfs2_xattr_set_ctxt *ctxt) 5586 { 5587 int ret; 5588 5589 mlog_entry("Set xattr %s in xattr index block\n", xi->xi_name); 5590 5591 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt); 5592 if (!ret) 5593 goto out; 5594 if (ret != -ENOSPC) { 5595 mlog_errno(ret); 5596 goto out; 5597 } 5598 5599 /* Ack, need more space. Let's try to get another bucket! */ 5600 5601 /* 5602 * We do not allow for overlapping ranges between buckets. And 5603 * the maximum number of collisions we will allow for then is 5604 * one bucket's worth, so check it here whether we need to 5605 * add a new bucket for the insert. 5606 */ 5607 ret = ocfs2_check_xattr_bucket_collision(inode, 5608 xs->bucket, 5609 xi->xi_name); 5610 if (ret) { 5611 mlog_errno(ret); 5612 goto out; 5613 } 5614 5615 ret = ocfs2_add_new_xattr_bucket(inode, 5616 xs->xattr_bh, 5617 xs->bucket, 5618 ctxt); 5619 if (ret) { 5620 mlog_errno(ret); 5621 goto out; 5622 } 5623 5624 /* 5625 * ocfs2_add_new_xattr_bucket() will have updated 5626 * xs->bucket if it moved, but it will not have updated 5627 * any of the other search fields. Thus, we drop it and 5628 * re-search. Everything should be cached, so it'll be 5629 * quick. 5630 */ 5631 ocfs2_xattr_bucket_relse(xs->bucket); 5632 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh, 5633 xi->xi_name_index, 5634 xi->xi_name, xs); 5635 if (ret && ret != -ENODATA) 5636 goto out; 5637 xs->not_found = ret; 5638 5639 /* Ok, we have a new bucket, let's try again */ 5640 ret = ocfs2_xattr_set_entry_bucket(inode, xi, xs, ctxt); 5641 if (ret && (ret != -ENOSPC)) 5642 mlog_errno(ret); 5643 5644 out: 5645 mlog_exit(ret); 5646 return ret; 5647 } 5648 5649 static int ocfs2_delete_xattr_in_bucket(struct inode *inode, 5650 struct ocfs2_xattr_bucket *bucket, 5651 void *para) 5652 { 5653 int ret = 0, ref_credits; 5654 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5655 u16 i; 5656 struct ocfs2_xattr_entry *xe; 5657 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5658 struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,}; 5659 int credits = ocfs2_remove_extent_credits(osb->sb) + 5660 ocfs2_blocks_per_xattr_bucket(inode->i_sb); 5661 struct ocfs2_xattr_value_root *xv; 5662 struct ocfs2_rm_xattr_bucket_para *args = 5663 (struct ocfs2_rm_xattr_bucket_para *)para; 5664 5665 ocfs2_init_dealloc_ctxt(&ctxt.dealloc); 5666 5667 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 5668 xe = &xh->xh_entries[i]; 5669 if (ocfs2_xattr_is_local(xe)) 5670 continue; 5671 5672 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, 5673 i, &xv, NULL); 5674 5675 ret = ocfs2_lock_xattr_remove_allocators(inode, xv, 5676 args->ref_ci, 5677 args->ref_root_bh, 5678 &ctxt.meta_ac, 5679 &ref_credits); 5680 5681 ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits); 5682 if (IS_ERR(ctxt.handle)) { 5683 ret = PTR_ERR(ctxt.handle); 5684 mlog_errno(ret); 5685 break; 5686 } 5687 5688 ret = ocfs2_xattr_bucket_value_truncate(inode, bucket, 5689 i, 0, &ctxt); 5690 5691 ocfs2_commit_trans(osb, ctxt.handle); 5692 if (ctxt.meta_ac) { 5693 ocfs2_free_alloc_context(ctxt.meta_ac); 5694 ctxt.meta_ac = NULL; 5695 } 5696 if (ret) { 5697 mlog_errno(ret); 5698 break; 5699 } 5700 } 5701 5702 if (ctxt.meta_ac) 5703 ocfs2_free_alloc_context(ctxt.meta_ac); 5704 ocfs2_schedule_truncate_log_flush(osb, 1); 5705 ocfs2_run_deallocs(osb, &ctxt.dealloc); 5706 return ret; 5707 } 5708 5709 /* 5710 * Whenever we modify a xattr value root in the bucket(e.g, CoW 5711 * or change the extent record flag), we need to recalculate 5712 * the metaecc for the whole bucket. So it is done here. 5713 * 5714 * Note: 5715 * We have to give the extra credits for the caller. 5716 */ 5717 static int ocfs2_xattr_bucket_post_refcount(struct inode *inode, 5718 handle_t *handle, 5719 void *para) 5720 { 5721 int ret; 5722 struct ocfs2_xattr_bucket *bucket = 5723 (struct ocfs2_xattr_bucket *)para; 5724 5725 ret = ocfs2_xattr_bucket_journal_access(handle, bucket, 5726 OCFS2_JOURNAL_ACCESS_WRITE); 5727 if (ret) { 5728 mlog_errno(ret); 5729 return ret; 5730 } 5731 5732 ocfs2_xattr_bucket_journal_dirty(handle, bucket); 5733 5734 return 0; 5735 } 5736 5737 /* 5738 * Special action we need if the xattr value is refcounted. 5739 * 5740 * 1. If the xattr is refcounted, lock the tree. 5741 * 2. CoW the xattr if we are setting the new value and the value 5742 * will be stored outside. 5743 * 3. In other case, decrease_refcount will work for us, so just 5744 * lock the refcount tree, calculate the meta and credits is OK. 5745 * 5746 * We have to do CoW before ocfs2_init_xattr_set_ctxt since 5747 * currently CoW is a completed transaction, while this function 5748 * will also lock the allocators and let us deadlock. So we will 5749 * CoW the whole xattr value. 5750 */ 5751 static int ocfs2_prepare_refcount_xattr(struct inode *inode, 5752 struct ocfs2_dinode *di, 5753 struct ocfs2_xattr_info *xi, 5754 struct ocfs2_xattr_search *xis, 5755 struct ocfs2_xattr_search *xbs, 5756 struct ocfs2_refcount_tree **ref_tree, 5757 int *meta_add, 5758 int *credits) 5759 { 5760 int ret = 0; 5761 struct ocfs2_xattr_block *xb; 5762 struct ocfs2_xattr_entry *xe; 5763 char *base; 5764 u32 p_cluster, num_clusters; 5765 unsigned int ext_flags; 5766 int name_offset, name_len; 5767 struct ocfs2_xattr_value_buf vb; 5768 struct ocfs2_xattr_bucket *bucket = NULL; 5769 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5770 struct ocfs2_post_refcount refcount; 5771 struct ocfs2_post_refcount *p = NULL; 5772 struct buffer_head *ref_root_bh = NULL; 5773 5774 if (!xis->not_found) { 5775 xe = xis->here; 5776 name_offset = le16_to_cpu(xe->xe_name_offset); 5777 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 5778 base = xis->base; 5779 vb.vb_bh = xis->inode_bh; 5780 vb.vb_access = ocfs2_journal_access_di; 5781 } else { 5782 int i, block_off = 0; 5783 xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data; 5784 xe = xbs->here; 5785 name_offset = le16_to_cpu(xe->xe_name_offset); 5786 name_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 5787 i = xbs->here - xbs->header->xh_entries; 5788 5789 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) { 5790 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, 5791 bucket_xh(xbs->bucket), 5792 i, &block_off, 5793 &name_offset); 5794 if (ret) { 5795 mlog_errno(ret); 5796 goto out; 5797 } 5798 base = bucket_block(xbs->bucket, block_off); 5799 vb.vb_bh = xbs->bucket->bu_bhs[block_off]; 5800 vb.vb_access = ocfs2_journal_access; 5801 5802 if (ocfs2_meta_ecc(osb)) { 5803 /*create parameters for ocfs2_post_refcount. */ 5804 bucket = xbs->bucket; 5805 refcount.credits = bucket->bu_blocks; 5806 refcount.para = bucket; 5807 refcount.func = 5808 ocfs2_xattr_bucket_post_refcount; 5809 p = &refcount; 5810 } 5811 } else { 5812 base = xbs->base; 5813 vb.vb_bh = xbs->xattr_bh; 5814 vb.vb_access = ocfs2_journal_access_xb; 5815 } 5816 } 5817 5818 if (ocfs2_xattr_is_local(xe)) 5819 goto out; 5820 5821 vb.vb_xv = (struct ocfs2_xattr_value_root *) 5822 (base + name_offset + name_len); 5823 5824 ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster, 5825 &num_clusters, &vb.vb_xv->xr_list, 5826 &ext_flags); 5827 if (ret) { 5828 mlog_errno(ret); 5829 goto out; 5830 } 5831 5832 /* 5833 * We just need to check the 1st extent record, since we always 5834 * CoW the whole xattr. So there shouldn't be a xattr with 5835 * some REFCOUNT extent recs after the 1st one. 5836 */ 5837 if (!(ext_flags & OCFS2_EXT_REFCOUNTED)) 5838 goto out; 5839 5840 ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc), 5841 1, ref_tree, &ref_root_bh); 5842 if (ret) { 5843 mlog_errno(ret); 5844 goto out; 5845 } 5846 5847 /* 5848 * If we are deleting the xattr or the new size will be stored inside, 5849 * cool, leave it there, the xattr truncate process will remove them 5850 * for us(it still needs the refcount tree lock and the meta, credits). 5851 * And the worse case is that every cluster truncate will split the 5852 * refcount tree, and make the original extent become 3. So we will need 5853 * 2 * cluster more extent recs at most. 5854 */ 5855 if (!xi->xi_value || xi->xi_value_len <= OCFS2_XATTR_INLINE_SIZE) { 5856 5857 ret = ocfs2_refcounted_xattr_delete_need(inode, 5858 &(*ref_tree)->rf_ci, 5859 ref_root_bh, vb.vb_xv, 5860 meta_add, credits); 5861 if (ret) 5862 mlog_errno(ret); 5863 goto out; 5864 } 5865 5866 ret = ocfs2_refcount_cow_xattr(inode, di, &vb, 5867 *ref_tree, ref_root_bh, 0, 5868 le32_to_cpu(vb.vb_xv->xr_clusters), p); 5869 if (ret) 5870 mlog_errno(ret); 5871 5872 out: 5873 brelse(ref_root_bh); 5874 return ret; 5875 } 5876 5877 /* 5878 * Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root. 5879 * The physical clusters will be added to refcount tree. 5880 */ 5881 static int ocfs2_xattr_value_attach_refcount(struct inode *inode, 5882 struct ocfs2_xattr_value_root *xv, 5883 struct ocfs2_extent_tree *value_et, 5884 struct ocfs2_caching_info *ref_ci, 5885 struct buffer_head *ref_root_bh, 5886 struct ocfs2_cached_dealloc_ctxt *dealloc, 5887 struct ocfs2_post_refcount *refcount) 5888 { 5889 int ret = 0; 5890 u32 clusters = le32_to_cpu(xv->xr_clusters); 5891 u32 cpos, p_cluster, num_clusters; 5892 struct ocfs2_extent_list *el = &xv->xr_list; 5893 unsigned int ext_flags; 5894 5895 cpos = 0; 5896 while (cpos < clusters) { 5897 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster, 5898 &num_clusters, el, &ext_flags); 5899 5900 cpos += num_clusters; 5901 if ((ext_flags & OCFS2_EXT_REFCOUNTED)) 5902 continue; 5903 5904 BUG_ON(!p_cluster); 5905 5906 ret = ocfs2_add_refcount_flag(inode, value_et, 5907 ref_ci, ref_root_bh, 5908 cpos - num_clusters, 5909 p_cluster, num_clusters, 5910 dealloc, refcount); 5911 if (ret) { 5912 mlog_errno(ret); 5913 break; 5914 } 5915 } 5916 5917 return ret; 5918 } 5919 5920 /* 5921 * Given a normal ocfs2_xattr_header, refcount all the entries which 5922 * have value stored outside. 5923 * Used for xattrs stored in inode and ocfs2_xattr_block. 5924 */ 5925 static int ocfs2_xattr_attach_refcount_normal(struct inode *inode, 5926 struct ocfs2_xattr_value_buf *vb, 5927 struct ocfs2_xattr_header *header, 5928 struct ocfs2_caching_info *ref_ci, 5929 struct buffer_head *ref_root_bh, 5930 struct ocfs2_cached_dealloc_ctxt *dealloc) 5931 { 5932 5933 struct ocfs2_xattr_entry *xe; 5934 struct ocfs2_xattr_value_root *xv; 5935 struct ocfs2_extent_tree et; 5936 int i, ret = 0; 5937 5938 for (i = 0; i < le16_to_cpu(header->xh_count); i++) { 5939 xe = &header->xh_entries[i]; 5940 5941 if (ocfs2_xattr_is_local(xe)) 5942 continue; 5943 5944 xv = (struct ocfs2_xattr_value_root *)((void *)header + 5945 le16_to_cpu(xe->xe_name_offset) + 5946 OCFS2_XATTR_SIZE(xe->xe_name_len)); 5947 5948 vb->vb_xv = xv; 5949 ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb); 5950 5951 ret = ocfs2_xattr_value_attach_refcount(inode, xv, &et, 5952 ref_ci, ref_root_bh, 5953 dealloc, NULL); 5954 if (ret) { 5955 mlog_errno(ret); 5956 break; 5957 } 5958 } 5959 5960 return ret; 5961 } 5962 5963 static int ocfs2_xattr_inline_attach_refcount(struct inode *inode, 5964 struct buffer_head *fe_bh, 5965 struct ocfs2_caching_info *ref_ci, 5966 struct buffer_head *ref_root_bh, 5967 struct ocfs2_cached_dealloc_ctxt *dealloc) 5968 { 5969 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data; 5970 struct ocfs2_xattr_header *header = (struct ocfs2_xattr_header *) 5971 (fe_bh->b_data + inode->i_sb->s_blocksize - 5972 le16_to_cpu(di->i_xattr_inline_size)); 5973 struct ocfs2_xattr_value_buf vb = { 5974 .vb_bh = fe_bh, 5975 .vb_access = ocfs2_journal_access_di, 5976 }; 5977 5978 return ocfs2_xattr_attach_refcount_normal(inode, &vb, header, 5979 ref_ci, ref_root_bh, dealloc); 5980 } 5981 5982 struct ocfs2_xattr_tree_value_refcount_para { 5983 struct ocfs2_caching_info *ref_ci; 5984 struct buffer_head *ref_root_bh; 5985 struct ocfs2_cached_dealloc_ctxt *dealloc; 5986 }; 5987 5988 static int ocfs2_get_xattr_tree_value_root(struct super_block *sb, 5989 struct ocfs2_xattr_bucket *bucket, 5990 int offset, 5991 struct ocfs2_xattr_value_root **xv, 5992 struct buffer_head **bh) 5993 { 5994 int ret, block_off, name_offset; 5995 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5996 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset]; 5997 void *base; 5998 5999 ret = ocfs2_xattr_bucket_get_name_value(sb, 6000 bucket_xh(bucket), 6001 offset, 6002 &block_off, 6003 &name_offset); 6004 if (ret) { 6005 mlog_errno(ret); 6006 goto out; 6007 } 6008 6009 base = bucket_block(bucket, block_off); 6010 6011 *xv = (struct ocfs2_xattr_value_root *)(base + name_offset + 6012 OCFS2_XATTR_SIZE(xe->xe_name_len)); 6013 6014 if (bh) 6015 *bh = bucket->bu_bhs[block_off]; 6016 out: 6017 return ret; 6018 } 6019 6020 /* 6021 * For a given xattr bucket, refcount all the entries which 6022 * have value stored outside. 6023 */ 6024 static int ocfs2_xattr_bucket_value_refcount(struct inode *inode, 6025 struct ocfs2_xattr_bucket *bucket, 6026 void *para) 6027 { 6028 int i, ret = 0; 6029 struct ocfs2_extent_tree et; 6030 struct ocfs2_xattr_tree_value_refcount_para *ref = 6031 (struct ocfs2_xattr_tree_value_refcount_para *)para; 6032 struct ocfs2_xattr_header *xh = 6033 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data; 6034 struct ocfs2_xattr_entry *xe; 6035 struct ocfs2_xattr_value_buf vb = { 6036 .vb_access = ocfs2_journal_access, 6037 }; 6038 struct ocfs2_post_refcount refcount = { 6039 .credits = bucket->bu_blocks, 6040 .para = bucket, 6041 .func = ocfs2_xattr_bucket_post_refcount, 6042 }; 6043 struct ocfs2_post_refcount *p = NULL; 6044 6045 /* We only need post_refcount if we support metaecc. */ 6046 if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb))) 6047 p = &refcount; 6048 6049 mlog(0, "refcount bucket %llu, count = %u\n", 6050 (unsigned long long)bucket_blkno(bucket), 6051 le16_to_cpu(xh->xh_count)); 6052 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 6053 xe = &xh->xh_entries[i]; 6054 6055 if (ocfs2_xattr_is_local(xe)) 6056 continue; 6057 6058 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i, 6059 &vb.vb_xv, &vb.vb_bh); 6060 if (ret) { 6061 mlog_errno(ret); 6062 break; 6063 } 6064 6065 ocfs2_init_xattr_value_extent_tree(&et, 6066 INODE_CACHE(inode), &vb); 6067 6068 ret = ocfs2_xattr_value_attach_refcount(inode, vb.vb_xv, 6069 &et, ref->ref_ci, 6070 ref->ref_root_bh, 6071 ref->dealloc, p); 6072 if (ret) { 6073 mlog_errno(ret); 6074 break; 6075 } 6076 } 6077 6078 return ret; 6079 6080 } 6081 6082 static int ocfs2_refcount_xattr_tree_rec(struct inode *inode, 6083 struct buffer_head *root_bh, 6084 u64 blkno, u32 cpos, u32 len, void *para) 6085 { 6086 return ocfs2_iterate_xattr_buckets(inode, blkno, len, 6087 ocfs2_xattr_bucket_value_refcount, 6088 para); 6089 } 6090 6091 static int ocfs2_xattr_block_attach_refcount(struct inode *inode, 6092 struct buffer_head *blk_bh, 6093 struct ocfs2_caching_info *ref_ci, 6094 struct buffer_head *ref_root_bh, 6095 struct ocfs2_cached_dealloc_ctxt *dealloc) 6096 { 6097 int ret = 0; 6098 struct ocfs2_xattr_block *xb = 6099 (struct ocfs2_xattr_block *)blk_bh->b_data; 6100 6101 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) { 6102 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header; 6103 struct ocfs2_xattr_value_buf vb = { 6104 .vb_bh = blk_bh, 6105 .vb_access = ocfs2_journal_access_xb, 6106 }; 6107 6108 ret = ocfs2_xattr_attach_refcount_normal(inode, &vb, header, 6109 ref_ci, ref_root_bh, 6110 dealloc); 6111 } else { 6112 struct ocfs2_xattr_tree_value_refcount_para para = { 6113 .ref_ci = ref_ci, 6114 .ref_root_bh = ref_root_bh, 6115 .dealloc = dealloc, 6116 }; 6117 6118 ret = ocfs2_iterate_xattr_index_block(inode, blk_bh, 6119 ocfs2_refcount_xattr_tree_rec, 6120 ¶); 6121 } 6122 6123 return ret; 6124 } 6125 6126 int ocfs2_xattr_attach_refcount_tree(struct inode *inode, 6127 struct buffer_head *fe_bh, 6128 struct ocfs2_caching_info *ref_ci, 6129 struct buffer_head *ref_root_bh, 6130 struct ocfs2_cached_dealloc_ctxt *dealloc) 6131 { 6132 int ret = 0; 6133 struct ocfs2_inode_info *oi = OCFS2_I(inode); 6134 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data; 6135 struct buffer_head *blk_bh = NULL; 6136 6137 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 6138 ret = ocfs2_xattr_inline_attach_refcount(inode, fe_bh, 6139 ref_ci, ref_root_bh, 6140 dealloc); 6141 if (ret) { 6142 mlog_errno(ret); 6143 goto out; 6144 } 6145 } 6146 6147 if (!di->i_xattr_loc) 6148 goto out; 6149 6150 ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc), 6151 &blk_bh); 6152 if (ret < 0) { 6153 mlog_errno(ret); 6154 goto out; 6155 } 6156 6157 ret = ocfs2_xattr_block_attach_refcount(inode, blk_bh, ref_ci, 6158 ref_root_bh, dealloc); 6159 if (ret) 6160 mlog_errno(ret); 6161 6162 brelse(blk_bh); 6163 out: 6164 6165 return ret; 6166 } 6167 6168 typedef int (should_xattr_reflinked)(struct ocfs2_xattr_entry *xe); 6169 /* 6170 * Store the information we need in xattr reflink. 6171 * old_bh and new_bh are inode bh for the old and new inode. 6172 */ 6173 struct ocfs2_xattr_reflink { 6174 struct inode *old_inode; 6175 struct inode *new_inode; 6176 struct buffer_head *old_bh; 6177 struct buffer_head *new_bh; 6178 struct ocfs2_caching_info *ref_ci; 6179 struct buffer_head *ref_root_bh; 6180 struct ocfs2_cached_dealloc_ctxt *dealloc; 6181 should_xattr_reflinked *xattr_reflinked; 6182 }; 6183 6184 /* 6185 * Given a xattr header and xe offset, 6186 * return the proper xv and the corresponding bh. 6187 * xattr in inode, block and xattr tree have different implementaions. 6188 */ 6189 typedef int (get_xattr_value_root)(struct super_block *sb, 6190 struct buffer_head *bh, 6191 struct ocfs2_xattr_header *xh, 6192 int offset, 6193 struct ocfs2_xattr_value_root **xv, 6194 struct buffer_head **ret_bh, 6195 void *para); 6196 6197 /* 6198 * Calculate all the xattr value root metadata stored in this xattr header and 6199 * credits we need if we create them from the scratch. 6200 * We use get_xattr_value_root so that all types of xattr container can use it. 6201 */ 6202 static int ocfs2_value_metas_in_xattr_header(struct super_block *sb, 6203 struct buffer_head *bh, 6204 struct ocfs2_xattr_header *xh, 6205 int *metas, int *credits, 6206 int *num_recs, 6207 get_xattr_value_root *func, 6208 void *para) 6209 { 6210 int i, ret = 0; 6211 struct ocfs2_xattr_value_root *xv; 6212 struct ocfs2_xattr_entry *xe; 6213 6214 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 6215 xe = &xh->xh_entries[i]; 6216 if (ocfs2_xattr_is_local(xe)) 6217 continue; 6218 6219 ret = func(sb, bh, xh, i, &xv, NULL, para); 6220 if (ret) { 6221 mlog_errno(ret); 6222 break; 6223 } 6224 6225 *metas += le16_to_cpu(xv->xr_list.l_tree_depth) * 6226 le16_to_cpu(xv->xr_list.l_next_free_rec); 6227 6228 *credits += ocfs2_calc_extend_credits(sb, 6229 &def_xv.xv.xr_list, 6230 le32_to_cpu(xv->xr_clusters)); 6231 6232 /* 6233 * If the value is a tree with depth > 1, We don't go deep 6234 * to the extent block, so just calculate a maximum record num. 6235 */ 6236 if (!xv->xr_list.l_tree_depth) 6237 *num_recs += le16_to_cpu(xv->xr_list.l_next_free_rec); 6238 else 6239 *num_recs += ocfs2_clusters_for_bytes(sb, 6240 XATTR_SIZE_MAX); 6241 } 6242 6243 return ret; 6244 } 6245 6246 /* Used by xattr inode and block to return the right xv and buffer_head. */ 6247 static int ocfs2_get_xattr_value_root(struct super_block *sb, 6248 struct buffer_head *bh, 6249 struct ocfs2_xattr_header *xh, 6250 int offset, 6251 struct ocfs2_xattr_value_root **xv, 6252 struct buffer_head **ret_bh, 6253 void *para) 6254 { 6255 struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset]; 6256 6257 *xv = (struct ocfs2_xattr_value_root *)((void *)xh + 6258 le16_to_cpu(xe->xe_name_offset) + 6259 OCFS2_XATTR_SIZE(xe->xe_name_len)); 6260 6261 if (ret_bh) 6262 *ret_bh = bh; 6263 6264 return 0; 6265 } 6266 6267 /* 6268 * Lock the meta_ac and caculate how much credits we need for reflink xattrs. 6269 * It is only used for inline xattr and xattr block. 6270 */ 6271 static int ocfs2_reflink_lock_xattr_allocators(struct ocfs2_super *osb, 6272 struct ocfs2_xattr_header *xh, 6273 struct buffer_head *ref_root_bh, 6274 int *credits, 6275 struct ocfs2_alloc_context **meta_ac) 6276 { 6277 int ret, meta_add = 0, num_recs = 0; 6278 struct ocfs2_refcount_block *rb = 6279 (struct ocfs2_refcount_block *)ref_root_bh->b_data; 6280 6281 *credits = 0; 6282 6283 ret = ocfs2_value_metas_in_xattr_header(osb->sb, NULL, xh, 6284 &meta_add, credits, &num_recs, 6285 ocfs2_get_xattr_value_root, 6286 NULL); 6287 if (ret) { 6288 mlog_errno(ret); 6289 goto out; 6290 } 6291 6292 /* 6293 * We need to add/modify num_recs in refcount tree, so just calculate 6294 * an approximate number we need for refcount tree change. 6295 * Sometimes we need to split the tree, and after split, half recs 6296 * will be moved to the new block, and a new block can only provide 6297 * half number of recs. So we multiple new blocks by 2. 6298 */ 6299 num_recs = num_recs / ocfs2_refcount_recs_per_rb(osb->sb) * 2; 6300 meta_add += num_recs; 6301 *credits += num_recs + num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS; 6302 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL) 6303 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) * 6304 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1; 6305 else 6306 *credits += 1; 6307 6308 ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, meta_ac); 6309 if (ret) 6310 mlog_errno(ret); 6311 6312 out: 6313 return ret; 6314 } 6315 6316 /* 6317 * Given a xattr header, reflink all the xattrs in this container. 6318 * It can be used for inode, block and bucket. 6319 * 6320 * NOTE: 6321 * Before we call this function, the caller has memcpy the xattr in 6322 * old_xh to the new_xh. 6323 * 6324 * If args.xattr_reflinked is set, call it to decide whether the xe should 6325 * be reflinked or not. If not, remove it from the new xattr header. 6326 */ 6327 static int ocfs2_reflink_xattr_header(handle_t *handle, 6328 struct ocfs2_xattr_reflink *args, 6329 struct buffer_head *old_bh, 6330 struct ocfs2_xattr_header *xh, 6331 struct buffer_head *new_bh, 6332 struct ocfs2_xattr_header *new_xh, 6333 struct ocfs2_xattr_value_buf *vb, 6334 struct ocfs2_alloc_context *meta_ac, 6335 get_xattr_value_root *func, 6336 void *para) 6337 { 6338 int ret = 0, i, j; 6339 struct super_block *sb = args->old_inode->i_sb; 6340 struct buffer_head *value_bh; 6341 struct ocfs2_xattr_entry *xe, *last; 6342 struct ocfs2_xattr_value_root *xv, *new_xv; 6343 struct ocfs2_extent_tree data_et; 6344 u32 clusters, cpos, p_cluster, num_clusters; 6345 unsigned int ext_flags = 0; 6346 6347 mlog(0, "reflink xattr in container %llu, count = %u\n", 6348 (unsigned long long)old_bh->b_blocknr, le16_to_cpu(xh->xh_count)); 6349 6350 last = &new_xh->xh_entries[le16_to_cpu(new_xh->xh_count)]; 6351 for (i = 0, j = 0; i < le16_to_cpu(xh->xh_count); i++, j++) { 6352 xe = &xh->xh_entries[i]; 6353 6354 if (args->xattr_reflinked && !args->xattr_reflinked(xe)) { 6355 xe = &new_xh->xh_entries[j]; 6356 6357 le16_add_cpu(&new_xh->xh_count, -1); 6358 if (new_xh->xh_count) { 6359 memmove(xe, xe + 1, 6360 (void *)last - (void *)xe); 6361 memset(last, 0, 6362 sizeof(struct ocfs2_xattr_entry)); 6363 } 6364 6365 /* 6366 * We don't want j to increase in the next round since 6367 * it is already moved ahead. 6368 */ 6369 j--; 6370 continue; 6371 } 6372 6373 if (ocfs2_xattr_is_local(xe)) 6374 continue; 6375 6376 ret = func(sb, old_bh, xh, i, &xv, NULL, para); 6377 if (ret) { 6378 mlog_errno(ret); 6379 break; 6380 } 6381 6382 ret = func(sb, new_bh, new_xh, j, &new_xv, &value_bh, para); 6383 if (ret) { 6384 mlog_errno(ret); 6385 break; 6386 } 6387 6388 /* 6389 * For the xattr which has l_tree_depth = 0, all the extent 6390 * recs have already be copied to the new xh with the 6391 * propriate OCFS2_EXT_REFCOUNTED flag we just need to 6392 * increase the refount count int the refcount tree. 6393 * 6394 * For the xattr which has l_tree_depth > 0, we need 6395 * to initialize it to the empty default value root, 6396 * and then insert the extents one by one. 6397 */ 6398 if (xv->xr_list.l_tree_depth) { 6399 memcpy(new_xv, &def_xv, sizeof(def_xv)); 6400 vb->vb_xv = new_xv; 6401 vb->vb_bh = value_bh; 6402 ocfs2_init_xattr_value_extent_tree(&data_et, 6403 INODE_CACHE(args->new_inode), vb); 6404 } 6405 6406 clusters = le32_to_cpu(xv->xr_clusters); 6407 cpos = 0; 6408 while (cpos < clusters) { 6409 ret = ocfs2_xattr_get_clusters(args->old_inode, 6410 cpos, 6411 &p_cluster, 6412 &num_clusters, 6413 &xv->xr_list, 6414 &ext_flags); 6415 if (ret) { 6416 mlog_errno(ret); 6417 goto out; 6418 } 6419 6420 BUG_ON(!p_cluster); 6421 6422 if (xv->xr_list.l_tree_depth) { 6423 ret = ocfs2_insert_extent(handle, 6424 &data_et, cpos, 6425 ocfs2_clusters_to_blocks( 6426 args->old_inode->i_sb, 6427 p_cluster), 6428 num_clusters, ext_flags, 6429 meta_ac); 6430 if (ret) { 6431 mlog_errno(ret); 6432 goto out; 6433 } 6434 } 6435 6436 ret = ocfs2_increase_refcount(handle, args->ref_ci, 6437 args->ref_root_bh, 6438 p_cluster, num_clusters, 6439 meta_ac, args->dealloc); 6440 if (ret) { 6441 mlog_errno(ret); 6442 goto out; 6443 } 6444 6445 cpos += num_clusters; 6446 } 6447 } 6448 6449 out: 6450 return ret; 6451 } 6452 6453 static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args) 6454 { 6455 int ret = 0, credits = 0; 6456 handle_t *handle; 6457 struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb); 6458 struct ocfs2_dinode *di = (struct ocfs2_dinode *)args->old_bh->b_data; 6459 int inline_size = le16_to_cpu(di->i_xattr_inline_size); 6460 int header_off = osb->sb->s_blocksize - inline_size; 6461 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *) 6462 (args->old_bh->b_data + header_off); 6463 struct ocfs2_xattr_header *new_xh = (struct ocfs2_xattr_header *) 6464 (args->new_bh->b_data + header_off); 6465 struct ocfs2_alloc_context *meta_ac = NULL; 6466 struct ocfs2_inode_info *new_oi; 6467 struct ocfs2_dinode *new_di; 6468 struct ocfs2_xattr_value_buf vb = { 6469 .vb_bh = args->new_bh, 6470 .vb_access = ocfs2_journal_access_di, 6471 }; 6472 6473 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh, 6474 &credits, &meta_ac); 6475 if (ret) { 6476 mlog_errno(ret); 6477 goto out; 6478 } 6479 6480 handle = ocfs2_start_trans(osb, credits); 6481 if (IS_ERR(handle)) { 6482 ret = PTR_ERR(handle); 6483 mlog_errno(ret); 6484 goto out; 6485 } 6486 6487 ret = ocfs2_journal_access_di(handle, INODE_CACHE(args->new_inode), 6488 args->new_bh, OCFS2_JOURNAL_ACCESS_WRITE); 6489 if (ret) { 6490 mlog_errno(ret); 6491 goto out_commit; 6492 } 6493 6494 memcpy(args->new_bh->b_data + header_off, 6495 args->old_bh->b_data + header_off, inline_size); 6496 6497 new_di = (struct ocfs2_dinode *)args->new_bh->b_data; 6498 new_di->i_xattr_inline_size = cpu_to_le16(inline_size); 6499 6500 ret = ocfs2_reflink_xattr_header(handle, args, args->old_bh, xh, 6501 args->new_bh, new_xh, &vb, meta_ac, 6502 ocfs2_get_xattr_value_root, NULL); 6503 if (ret) { 6504 mlog_errno(ret); 6505 goto out_commit; 6506 } 6507 6508 new_oi = OCFS2_I(args->new_inode); 6509 spin_lock(&new_oi->ip_lock); 6510 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL | OCFS2_INLINE_XATTR_FL; 6511 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features); 6512 spin_unlock(&new_oi->ip_lock); 6513 6514 ocfs2_journal_dirty(handle, args->new_bh); 6515 6516 out_commit: 6517 ocfs2_commit_trans(osb, handle); 6518 6519 out: 6520 if (meta_ac) 6521 ocfs2_free_alloc_context(meta_ac); 6522 return ret; 6523 } 6524 6525 static int ocfs2_create_empty_xattr_block(struct inode *inode, 6526 struct buffer_head *fe_bh, 6527 struct buffer_head **ret_bh, 6528 int indexed) 6529 { 6530 int ret; 6531 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 6532 struct ocfs2_xattr_set_ctxt ctxt; 6533 6534 memset(&ctxt, 0, sizeof(ctxt)); 6535 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &ctxt.meta_ac); 6536 if (ret < 0) { 6537 mlog_errno(ret); 6538 return ret; 6539 } 6540 6541 ctxt.handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_CREATE_CREDITS); 6542 if (IS_ERR(ctxt.handle)) { 6543 ret = PTR_ERR(ctxt.handle); 6544 mlog_errno(ret); 6545 goto out; 6546 } 6547 6548 mlog(0, "create new xattr block for inode %llu, index = %d\n", 6549 (unsigned long long)fe_bh->b_blocknr, indexed); 6550 ret = ocfs2_create_xattr_block(inode, fe_bh, &ctxt, indexed, 6551 ret_bh); 6552 if (ret) 6553 mlog_errno(ret); 6554 6555 ocfs2_commit_trans(osb, ctxt.handle); 6556 out: 6557 ocfs2_free_alloc_context(ctxt.meta_ac); 6558 return ret; 6559 } 6560 6561 static int ocfs2_reflink_xattr_block(struct ocfs2_xattr_reflink *args, 6562 struct buffer_head *blk_bh, 6563 struct buffer_head *new_blk_bh) 6564 { 6565 int ret = 0, credits = 0; 6566 handle_t *handle; 6567 struct ocfs2_inode_info *new_oi = OCFS2_I(args->new_inode); 6568 struct ocfs2_dinode *new_di; 6569 struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb); 6570 int header_off = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 6571 struct ocfs2_xattr_block *xb = 6572 (struct ocfs2_xattr_block *)blk_bh->b_data; 6573 struct ocfs2_xattr_header *xh = &xb->xb_attrs.xb_header; 6574 struct ocfs2_xattr_block *new_xb = 6575 (struct ocfs2_xattr_block *)new_blk_bh->b_data; 6576 struct ocfs2_xattr_header *new_xh = &new_xb->xb_attrs.xb_header; 6577 struct ocfs2_alloc_context *meta_ac; 6578 struct ocfs2_xattr_value_buf vb = { 6579 .vb_bh = new_blk_bh, 6580 .vb_access = ocfs2_journal_access_xb, 6581 }; 6582 6583 ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh, 6584 &credits, &meta_ac); 6585 if (ret) { 6586 mlog_errno(ret); 6587 return ret; 6588 } 6589 6590 /* One more credits in case we need to add xattr flags in new inode. */ 6591 handle = ocfs2_start_trans(osb, credits + 1); 6592 if (IS_ERR(handle)) { 6593 ret = PTR_ERR(handle); 6594 mlog_errno(ret); 6595 goto out; 6596 } 6597 6598 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) { 6599 ret = ocfs2_journal_access_di(handle, 6600 INODE_CACHE(args->new_inode), 6601 args->new_bh, 6602 OCFS2_JOURNAL_ACCESS_WRITE); 6603 if (ret) { 6604 mlog_errno(ret); 6605 goto out_commit; 6606 } 6607 } 6608 6609 ret = ocfs2_journal_access_xb(handle, INODE_CACHE(args->new_inode), 6610 new_blk_bh, OCFS2_JOURNAL_ACCESS_WRITE); 6611 if (ret) { 6612 mlog_errno(ret); 6613 goto out_commit; 6614 } 6615 6616 memcpy(new_blk_bh->b_data + header_off, blk_bh->b_data + header_off, 6617 osb->sb->s_blocksize - header_off); 6618 6619 ret = ocfs2_reflink_xattr_header(handle, args, blk_bh, xh, 6620 new_blk_bh, new_xh, &vb, meta_ac, 6621 ocfs2_get_xattr_value_root, NULL); 6622 if (ret) { 6623 mlog_errno(ret); 6624 goto out_commit; 6625 } 6626 6627 ocfs2_journal_dirty(handle, new_blk_bh); 6628 6629 if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) { 6630 new_di = (struct ocfs2_dinode *)args->new_bh->b_data; 6631 spin_lock(&new_oi->ip_lock); 6632 new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL; 6633 new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features); 6634 spin_unlock(&new_oi->ip_lock); 6635 6636 ocfs2_journal_dirty(handle, args->new_bh); 6637 } 6638 6639 out_commit: 6640 ocfs2_commit_trans(osb, handle); 6641 6642 out: 6643 ocfs2_free_alloc_context(meta_ac); 6644 return ret; 6645 } 6646 6647 struct ocfs2_reflink_xattr_tree_args { 6648 struct ocfs2_xattr_reflink *reflink; 6649 struct buffer_head *old_blk_bh; 6650 struct buffer_head *new_blk_bh; 6651 struct ocfs2_xattr_bucket *old_bucket; 6652 struct ocfs2_xattr_bucket *new_bucket; 6653 }; 6654 6655 /* 6656 * NOTE: 6657 * We have to handle the case that both old bucket and new bucket 6658 * will call this function to get the right ret_bh. 6659 * So The caller must give us the right bh. 6660 */ 6661 static int ocfs2_get_reflink_xattr_value_root(struct super_block *sb, 6662 struct buffer_head *bh, 6663 struct ocfs2_xattr_header *xh, 6664 int offset, 6665 struct ocfs2_xattr_value_root **xv, 6666 struct buffer_head **ret_bh, 6667 void *para) 6668 { 6669 struct ocfs2_reflink_xattr_tree_args *args = 6670 (struct ocfs2_reflink_xattr_tree_args *)para; 6671 struct ocfs2_xattr_bucket *bucket; 6672 6673 if (bh == args->old_bucket->bu_bhs[0]) 6674 bucket = args->old_bucket; 6675 else 6676 bucket = args->new_bucket; 6677 6678 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset, 6679 xv, ret_bh); 6680 } 6681 6682 struct ocfs2_value_tree_metas { 6683 int num_metas; 6684 int credits; 6685 int num_recs; 6686 }; 6687 6688 static int ocfs2_value_tree_metas_in_bucket(struct super_block *sb, 6689 struct buffer_head *bh, 6690 struct ocfs2_xattr_header *xh, 6691 int offset, 6692 struct ocfs2_xattr_value_root **xv, 6693 struct buffer_head **ret_bh, 6694 void *para) 6695 { 6696 struct ocfs2_xattr_bucket *bucket = 6697 (struct ocfs2_xattr_bucket *)para; 6698 6699 return ocfs2_get_xattr_tree_value_root(sb, bucket, offset, 6700 xv, ret_bh); 6701 } 6702 6703 static int ocfs2_calc_value_tree_metas(struct inode *inode, 6704 struct ocfs2_xattr_bucket *bucket, 6705 void *para) 6706 { 6707 struct ocfs2_value_tree_metas *metas = 6708 (struct ocfs2_value_tree_metas *)para; 6709 struct ocfs2_xattr_header *xh = 6710 (struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data; 6711 6712 /* Add the credits for this bucket first. */ 6713 metas->credits += bucket->bu_blocks; 6714 return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0], 6715 xh, &metas->num_metas, 6716 &metas->credits, &metas->num_recs, 6717 ocfs2_value_tree_metas_in_bucket, 6718 bucket); 6719 } 6720 6721 /* 6722 * Given a xattr extent rec starting from blkno and having len clusters, 6723 * iterate all the buckets calculate how much metadata we need for reflinking 6724 * all the ocfs2_xattr_value_root and lock the allocators accordingly. 6725 */ 6726 static int ocfs2_lock_reflink_xattr_rec_allocators( 6727 struct ocfs2_reflink_xattr_tree_args *args, 6728 struct ocfs2_extent_tree *xt_et, 6729 u64 blkno, u32 len, int *credits, 6730 struct ocfs2_alloc_context **meta_ac, 6731 struct ocfs2_alloc_context **data_ac) 6732 { 6733 int ret, num_free_extents; 6734 struct ocfs2_value_tree_metas metas; 6735 struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb); 6736 struct ocfs2_refcount_block *rb; 6737 6738 memset(&metas, 0, sizeof(metas)); 6739 6740 ret = ocfs2_iterate_xattr_buckets(args->reflink->old_inode, blkno, len, 6741 ocfs2_calc_value_tree_metas, &metas); 6742 if (ret) { 6743 mlog_errno(ret); 6744 goto out; 6745 } 6746 6747 *credits = metas.credits; 6748 6749 /* 6750 * Calculate we need for refcount tree change. 6751 * 6752 * We need to add/modify num_recs in refcount tree, so just calculate 6753 * an approximate number we need for refcount tree change. 6754 * Sometimes we need to split the tree, and after split, half recs 6755 * will be moved to the new block, and a new block can only provide 6756 * half number of recs. So we multiple new blocks by 2. 6757 * In the end, we have to add credits for modifying the already 6758 * existed refcount block. 6759 */ 6760 rb = (struct ocfs2_refcount_block *)args->reflink->ref_root_bh->b_data; 6761 metas.num_recs = 6762 (metas.num_recs + ocfs2_refcount_recs_per_rb(osb->sb) - 1) / 6763 ocfs2_refcount_recs_per_rb(osb->sb) * 2; 6764 metas.num_metas += metas.num_recs; 6765 *credits += metas.num_recs + 6766 metas.num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS; 6767 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL) 6768 *credits += le16_to_cpu(rb->rf_list.l_tree_depth) * 6769 le16_to_cpu(rb->rf_list.l_next_free_rec) + 1; 6770 else 6771 *credits += 1; 6772 6773 /* count in the xattr tree change. */ 6774 num_free_extents = ocfs2_num_free_extents(osb, xt_et); 6775 if (num_free_extents < 0) { 6776 ret = num_free_extents; 6777 mlog_errno(ret); 6778 goto out; 6779 } 6780 6781 if (num_free_extents < len) 6782 metas.num_metas += ocfs2_extend_meta_needed(xt_et->et_root_el); 6783 6784 *credits += ocfs2_calc_extend_credits(osb->sb, 6785 xt_et->et_root_el, len); 6786 6787 if (metas.num_metas) { 6788 ret = ocfs2_reserve_new_metadata_blocks(osb, metas.num_metas, 6789 meta_ac); 6790 if (ret) { 6791 mlog_errno(ret); 6792 goto out; 6793 } 6794 } 6795 6796 if (len) { 6797 ret = ocfs2_reserve_clusters(osb, len, data_ac); 6798 if (ret) 6799 mlog_errno(ret); 6800 } 6801 out: 6802 if (ret) { 6803 if (*meta_ac) { 6804 ocfs2_free_alloc_context(*meta_ac); 6805 meta_ac = NULL; 6806 } 6807 } 6808 6809 return ret; 6810 } 6811 6812 static int ocfs2_reflink_xattr_buckets(handle_t *handle, 6813 u64 blkno, u64 new_blkno, u32 clusters, 6814 struct ocfs2_alloc_context *meta_ac, 6815 struct ocfs2_alloc_context *data_ac, 6816 struct ocfs2_reflink_xattr_tree_args *args) 6817 { 6818 int i, j, ret = 0; 6819 struct super_block *sb = args->reflink->old_inode->i_sb; 6820 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb)); 6821 u32 num_buckets = clusters * bpc; 6822 int bpb = args->old_bucket->bu_blocks; 6823 struct ocfs2_xattr_value_buf vb = { 6824 .vb_access = ocfs2_journal_access, 6825 }; 6826 6827 for (i = 0; i < num_buckets; i++, blkno += bpb, new_blkno += bpb) { 6828 ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno); 6829 if (ret) { 6830 mlog_errno(ret); 6831 break; 6832 } 6833 6834 ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno); 6835 if (ret) { 6836 mlog_errno(ret); 6837 break; 6838 } 6839 6840 /* 6841 * The real bucket num in this series of blocks is stored 6842 * in the 1st bucket. 6843 */ 6844 if (i == 0) 6845 num_buckets = le16_to_cpu( 6846 bucket_xh(args->old_bucket)->xh_num_buckets); 6847 6848 ret = ocfs2_xattr_bucket_journal_access(handle, 6849 args->new_bucket, 6850 OCFS2_JOURNAL_ACCESS_CREATE); 6851 if (ret) { 6852 mlog_errno(ret); 6853 break; 6854 } 6855 6856 for (j = 0; j < bpb; j++) 6857 memcpy(bucket_block(args->new_bucket, j), 6858 bucket_block(args->old_bucket, j), 6859 sb->s_blocksize); 6860 6861 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket); 6862 6863 ret = ocfs2_reflink_xattr_header(handle, args->reflink, 6864 args->old_bucket->bu_bhs[0], 6865 bucket_xh(args->old_bucket), 6866 args->new_bucket->bu_bhs[0], 6867 bucket_xh(args->new_bucket), 6868 &vb, meta_ac, 6869 ocfs2_get_reflink_xattr_value_root, 6870 args); 6871 if (ret) { 6872 mlog_errno(ret); 6873 break; 6874 } 6875 6876 /* 6877 * Re-access and dirty the bucket to calculate metaecc. 6878 * Because we may extend the transaction in reflink_xattr_header 6879 * which will let the already accessed block gone. 6880 */ 6881 ret = ocfs2_xattr_bucket_journal_access(handle, 6882 args->new_bucket, 6883 OCFS2_JOURNAL_ACCESS_WRITE); 6884 if (ret) { 6885 mlog_errno(ret); 6886 break; 6887 } 6888 6889 ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket); 6890 ocfs2_xattr_bucket_relse(args->old_bucket); 6891 ocfs2_xattr_bucket_relse(args->new_bucket); 6892 } 6893 6894 ocfs2_xattr_bucket_relse(args->old_bucket); 6895 ocfs2_xattr_bucket_relse(args->new_bucket); 6896 return ret; 6897 } 6898 /* 6899 * Create the same xattr extent record in the new inode's xattr tree. 6900 */ 6901 static int ocfs2_reflink_xattr_rec(struct inode *inode, 6902 struct buffer_head *root_bh, 6903 u64 blkno, 6904 u32 cpos, 6905 u32 len, 6906 void *para) 6907 { 6908 int ret, credits = 0; 6909 u32 p_cluster, num_clusters; 6910 u64 new_blkno; 6911 handle_t *handle; 6912 struct ocfs2_reflink_xattr_tree_args *args = 6913 (struct ocfs2_reflink_xattr_tree_args *)para; 6914 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 6915 struct ocfs2_alloc_context *meta_ac = NULL; 6916 struct ocfs2_alloc_context *data_ac = NULL; 6917 struct ocfs2_extent_tree et; 6918 6919 ocfs2_init_xattr_tree_extent_tree(&et, 6920 INODE_CACHE(args->reflink->new_inode), 6921 args->new_blk_bh); 6922 6923 ret = ocfs2_lock_reflink_xattr_rec_allocators(args, &et, blkno, 6924 len, &credits, 6925 &meta_ac, &data_ac); 6926 if (ret) { 6927 mlog_errno(ret); 6928 goto out; 6929 } 6930 6931 handle = ocfs2_start_trans(osb, credits); 6932 if (IS_ERR(handle)) { 6933 ret = PTR_ERR(handle); 6934 mlog_errno(ret); 6935 goto out; 6936 } 6937 6938 ret = ocfs2_claim_clusters(osb, handle, data_ac, 6939 len, &p_cluster, &num_clusters); 6940 if (ret) { 6941 mlog_errno(ret); 6942 goto out_commit; 6943 } 6944 6945 new_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cluster); 6946 6947 mlog(0, "reflink xattr buckets %llu to %llu, len %u\n", 6948 (unsigned long long)blkno, (unsigned long long)new_blkno, len); 6949 ret = ocfs2_reflink_xattr_buckets(handle, blkno, new_blkno, len, 6950 meta_ac, data_ac, args); 6951 if (ret) { 6952 mlog_errno(ret); 6953 goto out_commit; 6954 } 6955 6956 mlog(0, "insert new xattr extent rec start %llu len %u to %u\n", 6957 (unsigned long long)new_blkno, len, cpos); 6958 ret = ocfs2_insert_extent(handle, &et, cpos, new_blkno, 6959 len, 0, meta_ac); 6960 if (ret) 6961 mlog_errno(ret); 6962 6963 out_commit: 6964 ocfs2_commit_trans(osb, handle); 6965 6966 out: 6967 if (meta_ac) 6968 ocfs2_free_alloc_context(meta_ac); 6969 if (data_ac) 6970 ocfs2_free_alloc_context(data_ac); 6971 return ret; 6972 } 6973 6974 /* 6975 * Create reflinked xattr buckets. 6976 * We will add bucket one by one, and refcount all the xattrs in the bucket 6977 * if they are stored outside. 6978 */ 6979 static int ocfs2_reflink_xattr_tree(struct ocfs2_xattr_reflink *args, 6980 struct buffer_head *blk_bh, 6981 struct buffer_head *new_blk_bh) 6982 { 6983 int ret; 6984 struct ocfs2_reflink_xattr_tree_args para; 6985 6986 memset(¶, 0, sizeof(para)); 6987 para.reflink = args; 6988 para.old_blk_bh = blk_bh; 6989 para.new_blk_bh = new_blk_bh; 6990 6991 para.old_bucket = ocfs2_xattr_bucket_new(args->old_inode); 6992 if (!para.old_bucket) { 6993 mlog_errno(-ENOMEM); 6994 return -ENOMEM; 6995 } 6996 6997 para.new_bucket = ocfs2_xattr_bucket_new(args->new_inode); 6998 if (!para.new_bucket) { 6999 ret = -ENOMEM; 7000 mlog_errno(ret); 7001 goto out; 7002 } 7003 7004 ret = ocfs2_iterate_xattr_index_block(args->old_inode, blk_bh, 7005 ocfs2_reflink_xattr_rec, 7006 ¶); 7007 if (ret) 7008 mlog_errno(ret); 7009 7010 out: 7011 ocfs2_xattr_bucket_free(para.old_bucket); 7012 ocfs2_xattr_bucket_free(para.new_bucket); 7013 return ret; 7014 } 7015 7016 static int ocfs2_reflink_xattr_in_block(struct ocfs2_xattr_reflink *args, 7017 struct buffer_head *blk_bh) 7018 { 7019 int ret, indexed = 0; 7020 struct buffer_head *new_blk_bh = NULL; 7021 struct ocfs2_xattr_block *xb = 7022 (struct ocfs2_xattr_block *)blk_bh->b_data; 7023 7024 7025 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) 7026 indexed = 1; 7027 7028 ret = ocfs2_create_empty_xattr_block(args->new_inode, args->new_bh, 7029 &new_blk_bh, indexed); 7030 if (ret) { 7031 mlog_errno(ret); 7032 goto out; 7033 } 7034 7035 if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) 7036 ret = ocfs2_reflink_xattr_block(args, blk_bh, new_blk_bh); 7037 else 7038 ret = ocfs2_reflink_xattr_tree(args, blk_bh, new_blk_bh); 7039 if (ret) 7040 mlog_errno(ret); 7041 7042 out: 7043 brelse(new_blk_bh); 7044 return ret; 7045 } 7046 7047 static int ocfs2_reflink_xattr_no_security(struct ocfs2_xattr_entry *xe) 7048 { 7049 int type = ocfs2_xattr_get_type(xe); 7050 7051 return type != OCFS2_XATTR_INDEX_SECURITY && 7052 type != OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS && 7053 type != OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT; 7054 } 7055 7056 int ocfs2_reflink_xattrs(struct inode *old_inode, 7057 struct buffer_head *old_bh, 7058 struct inode *new_inode, 7059 struct buffer_head *new_bh, 7060 bool preserve_security) 7061 { 7062 int ret; 7063 struct ocfs2_xattr_reflink args; 7064 struct ocfs2_inode_info *oi = OCFS2_I(old_inode); 7065 struct ocfs2_dinode *di = (struct ocfs2_dinode *)old_bh->b_data; 7066 struct buffer_head *blk_bh = NULL; 7067 struct ocfs2_cached_dealloc_ctxt dealloc; 7068 struct ocfs2_refcount_tree *ref_tree; 7069 struct buffer_head *ref_root_bh = NULL; 7070 7071 ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb), 7072 le64_to_cpu(di->i_refcount_loc), 7073 1, &ref_tree, &ref_root_bh); 7074 if (ret) { 7075 mlog_errno(ret); 7076 goto out; 7077 } 7078 7079 ocfs2_init_dealloc_ctxt(&dealloc); 7080 7081 args.old_inode = old_inode; 7082 args.new_inode = new_inode; 7083 args.old_bh = old_bh; 7084 args.new_bh = new_bh; 7085 args.ref_ci = &ref_tree->rf_ci; 7086 args.ref_root_bh = ref_root_bh; 7087 args.dealloc = &dealloc; 7088 if (preserve_security) 7089 args.xattr_reflinked = NULL; 7090 else 7091 args.xattr_reflinked = ocfs2_reflink_xattr_no_security; 7092 7093 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) { 7094 ret = ocfs2_reflink_xattr_inline(&args); 7095 if (ret) { 7096 mlog_errno(ret); 7097 goto out_unlock; 7098 } 7099 } 7100 7101 if (!di->i_xattr_loc) 7102 goto out_unlock; 7103 7104 ret = ocfs2_read_xattr_block(old_inode, le64_to_cpu(di->i_xattr_loc), 7105 &blk_bh); 7106 if (ret < 0) { 7107 mlog_errno(ret); 7108 goto out_unlock; 7109 } 7110 7111 ret = ocfs2_reflink_xattr_in_block(&args, blk_bh); 7112 if (ret) 7113 mlog_errno(ret); 7114 7115 brelse(blk_bh); 7116 7117 out_unlock: 7118 ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb), 7119 ref_tree, 1); 7120 brelse(ref_root_bh); 7121 7122 if (ocfs2_dealloc_has_cluster(&dealloc)) { 7123 ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1); 7124 ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc); 7125 } 7126 7127 out: 7128 return ret; 7129 } 7130 7131 /* 7132 * Initialize security and acl for a already created inode. 7133 * Used for reflink a non-preserve-security file. 7134 * 7135 * It uses common api like ocfs2_xattr_set, so the caller 7136 * must not hold any lock expect i_mutex. 7137 */ 7138 int ocfs2_init_security_and_acl(struct inode *dir, 7139 struct inode *inode) 7140 { 7141 int ret = 0; 7142 struct buffer_head *dir_bh = NULL; 7143 struct ocfs2_security_xattr_info si = { 7144 .enable = 1, 7145 }; 7146 7147 ret = ocfs2_init_security_get(inode, dir, &si); 7148 if (!ret) { 7149 ret = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY, 7150 si.name, si.value, si.value_len, 7151 XATTR_CREATE); 7152 if (ret) { 7153 mlog_errno(ret); 7154 goto leave; 7155 } 7156 } else if (ret != -EOPNOTSUPP) { 7157 mlog_errno(ret); 7158 goto leave; 7159 } 7160 7161 ret = ocfs2_inode_lock(dir, &dir_bh, 0); 7162 if (ret) { 7163 mlog_errno(ret); 7164 goto leave; 7165 } 7166 7167 ret = ocfs2_init_acl(NULL, inode, dir, NULL, dir_bh, NULL, NULL); 7168 if (ret) 7169 mlog_errno(ret); 7170 7171 ocfs2_inode_unlock(dir, 0); 7172 brelse(dir_bh); 7173 leave: 7174 return ret; 7175 } 7176 /* 7177 * 'security' attributes support 7178 */ 7179 static size_t ocfs2_xattr_security_list(struct dentry *dentry, char *list, 7180 size_t list_size, const char *name, 7181 size_t name_len, int type) 7182 { 7183 const size_t prefix_len = XATTR_SECURITY_PREFIX_LEN; 7184 const size_t total_len = prefix_len + name_len + 1; 7185 7186 if (list && total_len <= list_size) { 7187 memcpy(list, XATTR_SECURITY_PREFIX, prefix_len); 7188 memcpy(list + prefix_len, name, name_len); 7189 list[prefix_len + name_len] = '\0'; 7190 } 7191 return total_len; 7192 } 7193 7194 static int ocfs2_xattr_security_get(struct dentry *dentry, const char *name, 7195 void *buffer, size_t size, int type) 7196 { 7197 if (strcmp(name, "") == 0) 7198 return -EINVAL; 7199 return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY, 7200 name, buffer, size); 7201 } 7202 7203 static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name, 7204 const void *value, size_t size, int flags, int type) 7205 { 7206 if (strcmp(name, "") == 0) 7207 return -EINVAL; 7208 7209 return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY, 7210 name, value, size, flags); 7211 } 7212 7213 int ocfs2_init_security_get(struct inode *inode, 7214 struct inode *dir, 7215 struct ocfs2_security_xattr_info *si) 7216 { 7217 /* check whether ocfs2 support feature xattr */ 7218 if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb))) 7219 return -EOPNOTSUPP; 7220 return security_inode_init_security(inode, dir, &si->name, &si->value, 7221 &si->value_len); 7222 } 7223 7224 int ocfs2_init_security_set(handle_t *handle, 7225 struct inode *inode, 7226 struct buffer_head *di_bh, 7227 struct ocfs2_security_xattr_info *si, 7228 struct ocfs2_alloc_context *xattr_ac, 7229 struct ocfs2_alloc_context *data_ac) 7230 { 7231 return ocfs2_xattr_set_handle(handle, inode, di_bh, 7232 OCFS2_XATTR_INDEX_SECURITY, 7233 si->name, si->value, si->value_len, 0, 7234 xattr_ac, data_ac); 7235 } 7236 7237 struct xattr_handler ocfs2_xattr_security_handler = { 7238 .prefix = XATTR_SECURITY_PREFIX, 7239 .list = ocfs2_xattr_security_list, 7240 .get = ocfs2_xattr_security_get, 7241 .set = ocfs2_xattr_security_set, 7242 }; 7243 7244 /* 7245 * 'trusted' attributes support 7246 */ 7247 static size_t ocfs2_xattr_trusted_list(struct dentry *dentry, char *list, 7248 size_t list_size, const char *name, 7249 size_t name_len, int type) 7250 { 7251 const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN; 7252 const size_t total_len = prefix_len + name_len + 1; 7253 7254 if (list && total_len <= list_size) { 7255 memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len); 7256 memcpy(list + prefix_len, name, name_len); 7257 list[prefix_len + name_len] = '\0'; 7258 } 7259 return total_len; 7260 } 7261 7262 static int ocfs2_xattr_trusted_get(struct dentry *dentry, const char *name, 7263 void *buffer, size_t size, int type) 7264 { 7265 if (strcmp(name, "") == 0) 7266 return -EINVAL; 7267 return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED, 7268 name, buffer, size); 7269 } 7270 7271 static int ocfs2_xattr_trusted_set(struct dentry *dentry, const char *name, 7272 const void *value, size_t size, int flags, int type) 7273 { 7274 if (strcmp(name, "") == 0) 7275 return -EINVAL; 7276 7277 return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED, 7278 name, value, size, flags); 7279 } 7280 7281 struct xattr_handler ocfs2_xattr_trusted_handler = { 7282 .prefix = XATTR_TRUSTED_PREFIX, 7283 .list = ocfs2_xattr_trusted_list, 7284 .get = ocfs2_xattr_trusted_get, 7285 .set = ocfs2_xattr_trusted_set, 7286 }; 7287 7288 /* 7289 * 'user' attributes support 7290 */ 7291 static size_t ocfs2_xattr_user_list(struct dentry *dentry, char *list, 7292 size_t list_size, const char *name, 7293 size_t name_len, int type) 7294 { 7295 const size_t prefix_len = XATTR_USER_PREFIX_LEN; 7296 const size_t total_len = prefix_len + name_len + 1; 7297 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb); 7298 7299 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 7300 return 0; 7301 7302 if (list && total_len <= list_size) { 7303 memcpy(list, XATTR_USER_PREFIX, prefix_len); 7304 memcpy(list + prefix_len, name, name_len); 7305 list[prefix_len + name_len] = '\0'; 7306 } 7307 return total_len; 7308 } 7309 7310 static int ocfs2_xattr_user_get(struct dentry *dentry, const char *name, 7311 void *buffer, size_t size, int type) 7312 { 7313 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb); 7314 7315 if (strcmp(name, "") == 0) 7316 return -EINVAL; 7317 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 7318 return -EOPNOTSUPP; 7319 return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name, 7320 buffer, size); 7321 } 7322 7323 static int ocfs2_xattr_user_set(struct dentry *dentry, const char *name, 7324 const void *value, size_t size, int flags, int type) 7325 { 7326 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb); 7327 7328 if (strcmp(name, "") == 0) 7329 return -EINVAL; 7330 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 7331 return -EOPNOTSUPP; 7332 7333 return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER, 7334 name, value, size, flags); 7335 } 7336 7337 struct xattr_handler ocfs2_xattr_user_handler = { 7338 .prefix = XATTR_USER_PREFIX, 7339 .list = ocfs2_xattr_user_list, 7340 .get = ocfs2_xattr_user_get, 7341 .set = ocfs2_xattr_user_set, 7342 }; 7343