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