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) 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 mlog_errno(ret); 3265 goto out; 3266 } 3267 3268 if (e_cpos == 0) 3269 break; 3270 3271 name_hash = e_cpos - 1; 3272 } 3273 3274 ret = xl.result; 3275 out: 3276 return ret; 3277 } 3278 3279 static int cmp_xe(const void *a, const void *b) 3280 { 3281 const struct ocfs2_xattr_entry *l = a, *r = b; 3282 u32 l_hash = le32_to_cpu(l->xe_name_hash); 3283 u32 r_hash = le32_to_cpu(r->xe_name_hash); 3284 3285 if (l_hash > r_hash) 3286 return 1; 3287 if (l_hash < r_hash) 3288 return -1; 3289 return 0; 3290 } 3291 3292 static void swap_xe(void *a, void *b, int size) 3293 { 3294 struct ocfs2_xattr_entry *l = a, *r = b, tmp; 3295 3296 tmp = *l; 3297 memcpy(l, r, sizeof(struct ocfs2_xattr_entry)); 3298 memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry)); 3299 } 3300 3301 /* 3302 * When the ocfs2_xattr_block is filled up, new bucket will be created 3303 * and all the xattr entries will be moved to the new bucket. 3304 * The header goes at the start of the bucket, and the names+values are 3305 * filled from the end. This is why *target starts as the last buffer. 3306 * Note: we need to sort the entries since they are not saved in order 3307 * in the ocfs2_xattr_block. 3308 */ 3309 static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode, 3310 struct buffer_head *xb_bh, 3311 struct ocfs2_xattr_bucket *bucket) 3312 { 3313 int i, blocksize = inode->i_sb->s_blocksize; 3314 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 3315 u16 offset, size, off_change; 3316 struct ocfs2_xattr_entry *xe; 3317 struct ocfs2_xattr_block *xb = 3318 (struct ocfs2_xattr_block *)xb_bh->b_data; 3319 struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header; 3320 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 3321 u16 count = le16_to_cpu(xb_xh->xh_count); 3322 char *src = xb_bh->b_data; 3323 char *target = bucket_block(bucket, blks - 1); 3324 3325 mlog(0, "cp xattr from block %llu to bucket %llu\n", 3326 (unsigned long long)xb_bh->b_blocknr, 3327 (unsigned long long)bucket_blkno(bucket)); 3328 3329 for (i = 0; i < blks; i++) 3330 memset(bucket_block(bucket, i), 0, blocksize); 3331 3332 /* 3333 * Since the xe_name_offset is based on ocfs2_xattr_header, 3334 * there is a offset change corresponding to the change of 3335 * ocfs2_xattr_header's position. 3336 */ 3337 off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 3338 xe = &xb_xh->xh_entries[count - 1]; 3339 offset = le16_to_cpu(xe->xe_name_offset) + off_change; 3340 size = blocksize - offset; 3341 3342 /* copy all the names and values. */ 3343 memcpy(target + offset, src + offset, size); 3344 3345 /* Init new header now. */ 3346 xh->xh_count = xb_xh->xh_count; 3347 xh->xh_num_buckets = cpu_to_le16(1); 3348 xh->xh_name_value_len = cpu_to_le16(size); 3349 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size); 3350 3351 /* copy all the entries. */ 3352 target = bucket_block(bucket, 0); 3353 offset = offsetof(struct ocfs2_xattr_header, xh_entries); 3354 size = count * sizeof(struct ocfs2_xattr_entry); 3355 memcpy(target + offset, (char *)xb_xh + offset, size); 3356 3357 /* Change the xe offset for all the xe because of the move. */ 3358 off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize + 3359 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header); 3360 for (i = 0; i < count; i++) 3361 le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change); 3362 3363 mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n", 3364 offset, size, off_change); 3365 3366 sort(target + offset, count, sizeof(struct ocfs2_xattr_entry), 3367 cmp_xe, swap_xe); 3368 } 3369 3370 /* 3371 * After we move xattr from block to index btree, we have to 3372 * update ocfs2_xattr_search to the new xe and base. 3373 * 3374 * When the entry is in xattr block, xattr_bh indicates the storage place. 3375 * While if the entry is in index b-tree, "bucket" indicates the 3376 * real place of the xattr. 3377 */ 3378 static void ocfs2_xattr_update_xattr_search(struct inode *inode, 3379 struct ocfs2_xattr_search *xs, 3380 struct buffer_head *old_bh) 3381 { 3382 char *buf = old_bh->b_data; 3383 struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf; 3384 struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header; 3385 int i; 3386 3387 xs->header = bucket_xh(xs->bucket); 3388 xs->base = bucket_block(xs->bucket, 0); 3389 xs->end = xs->base + inode->i_sb->s_blocksize; 3390 3391 if (xs->not_found) 3392 return; 3393 3394 i = xs->here - old_xh->xh_entries; 3395 xs->here = &xs->header->xh_entries[i]; 3396 } 3397 3398 static int ocfs2_xattr_create_index_block(struct inode *inode, 3399 struct ocfs2_xattr_search *xs, 3400 struct ocfs2_xattr_set_ctxt *ctxt) 3401 { 3402 int ret; 3403 u32 bit_off, len; 3404 u64 blkno; 3405 handle_t *handle = ctxt->handle; 3406 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 3407 struct ocfs2_inode_info *oi = OCFS2_I(inode); 3408 struct buffer_head *xb_bh = xs->xattr_bh; 3409 struct ocfs2_xattr_block *xb = 3410 (struct ocfs2_xattr_block *)xb_bh->b_data; 3411 struct ocfs2_xattr_tree_root *xr; 3412 u16 xb_flags = le16_to_cpu(xb->xb_flags); 3413 3414 mlog(0, "create xattr index block for %llu\n", 3415 (unsigned long long)xb_bh->b_blocknr); 3416 3417 BUG_ON(xb_flags & OCFS2_XATTR_INDEXED); 3418 BUG_ON(!xs->bucket); 3419 3420 /* 3421 * XXX: 3422 * We can use this lock for now, and maybe move to a dedicated mutex 3423 * if performance becomes a problem later. 3424 */ 3425 down_write(&oi->ip_alloc_sem); 3426 3427 ret = ocfs2_journal_access_xb(handle, inode, xb_bh, 3428 OCFS2_JOURNAL_ACCESS_WRITE); 3429 if (ret) { 3430 mlog_errno(ret); 3431 goto out; 3432 } 3433 3434 ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 3435 1, 1, &bit_off, &len); 3436 if (ret) { 3437 mlog_errno(ret); 3438 goto out; 3439 } 3440 3441 /* 3442 * The bucket may spread in many blocks, and 3443 * we will only touch the 1st block and the last block 3444 * in the whole bucket(one for entry and one for data). 3445 */ 3446 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); 3447 3448 mlog(0, "allocate 1 cluster from %llu to xattr block\n", 3449 (unsigned long long)blkno); 3450 3451 ret = ocfs2_init_xattr_bucket(xs->bucket, blkno); 3452 if (ret) { 3453 mlog_errno(ret); 3454 goto out; 3455 } 3456 3457 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket, 3458 OCFS2_JOURNAL_ACCESS_CREATE); 3459 if (ret) { 3460 mlog_errno(ret); 3461 goto out; 3462 } 3463 3464 ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket); 3465 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket); 3466 3467 ocfs2_xattr_update_xattr_search(inode, xs, xb_bh); 3468 3469 /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */ 3470 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize - 3471 offsetof(struct ocfs2_xattr_block, xb_attrs)); 3472 3473 xr = &xb->xb_attrs.xb_root; 3474 xr->xt_clusters = cpu_to_le32(1); 3475 xr->xt_last_eb_blk = 0; 3476 xr->xt_list.l_tree_depth = 0; 3477 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb)); 3478 xr->xt_list.l_next_free_rec = cpu_to_le16(1); 3479 3480 xr->xt_list.l_recs[0].e_cpos = 0; 3481 xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno); 3482 xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1); 3483 3484 xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED); 3485 3486 ocfs2_journal_dirty(handle, xb_bh); 3487 3488 out: 3489 up_write(&oi->ip_alloc_sem); 3490 3491 return ret; 3492 } 3493 3494 static int cmp_xe_offset(const void *a, const void *b) 3495 { 3496 const struct ocfs2_xattr_entry *l = a, *r = b; 3497 u32 l_name_offset = le16_to_cpu(l->xe_name_offset); 3498 u32 r_name_offset = le16_to_cpu(r->xe_name_offset); 3499 3500 if (l_name_offset < r_name_offset) 3501 return 1; 3502 if (l_name_offset > r_name_offset) 3503 return -1; 3504 return 0; 3505 } 3506 3507 /* 3508 * defrag a xattr bucket if we find that the bucket has some 3509 * holes beteen name/value pairs. 3510 * We will move all the name/value pairs to the end of the bucket 3511 * so that we can spare some space for insertion. 3512 */ 3513 static int ocfs2_defrag_xattr_bucket(struct inode *inode, 3514 handle_t *handle, 3515 struct ocfs2_xattr_bucket *bucket) 3516 { 3517 int ret, i; 3518 size_t end, offset, len, value_len; 3519 struct ocfs2_xattr_header *xh; 3520 char *entries, *buf, *bucket_buf = NULL; 3521 u64 blkno = bucket_blkno(bucket); 3522 u16 xh_free_start; 3523 size_t blocksize = inode->i_sb->s_blocksize; 3524 struct ocfs2_xattr_entry *xe; 3525 3526 /* 3527 * In order to make the operation more efficient and generic, 3528 * we copy all the blocks into a contiguous memory and do the 3529 * defragment there, so if anything is error, we will not touch 3530 * the real block. 3531 */ 3532 bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS); 3533 if (!bucket_buf) { 3534 ret = -EIO; 3535 goto out; 3536 } 3537 3538 buf = bucket_buf; 3539 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize) 3540 memcpy(buf, bucket_block(bucket, i), blocksize); 3541 3542 ret = ocfs2_xattr_bucket_journal_access(handle, bucket, 3543 OCFS2_JOURNAL_ACCESS_WRITE); 3544 if (ret < 0) { 3545 mlog_errno(ret); 3546 goto out; 3547 } 3548 3549 xh = (struct ocfs2_xattr_header *)bucket_buf; 3550 entries = (char *)xh->xh_entries; 3551 xh_free_start = le16_to_cpu(xh->xh_free_start); 3552 3553 mlog(0, "adjust xattr bucket in %llu, count = %u, " 3554 "xh_free_start = %u, xh_name_value_len = %u.\n", 3555 (unsigned long long)blkno, le16_to_cpu(xh->xh_count), 3556 xh_free_start, le16_to_cpu(xh->xh_name_value_len)); 3557 3558 /* 3559 * sort all the entries by their offset. 3560 * the largest will be the first, so that we can 3561 * move them to the end one by one. 3562 */ 3563 sort(entries, le16_to_cpu(xh->xh_count), 3564 sizeof(struct ocfs2_xattr_entry), 3565 cmp_xe_offset, swap_xe); 3566 3567 /* Move all name/values to the end of the bucket. */ 3568 xe = xh->xh_entries; 3569 end = OCFS2_XATTR_BUCKET_SIZE; 3570 for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) { 3571 offset = le16_to_cpu(xe->xe_name_offset); 3572 if (ocfs2_xattr_is_local(xe)) 3573 value_len = OCFS2_XATTR_SIZE( 3574 le64_to_cpu(xe->xe_value_size)); 3575 else 3576 value_len = OCFS2_XATTR_ROOT_SIZE; 3577 len = OCFS2_XATTR_SIZE(xe->xe_name_len) + value_len; 3578 3579 /* 3580 * We must make sure that the name/value pair 3581 * exist in the same block. So adjust end to 3582 * the previous block end if needed. 3583 */ 3584 if (((end - len) / blocksize != 3585 (end - 1) / blocksize)) 3586 end = end - end % blocksize; 3587 3588 if (end > offset + len) { 3589 memmove(bucket_buf + end - len, 3590 bucket_buf + offset, len); 3591 xe->xe_name_offset = cpu_to_le16(end - len); 3592 } 3593 3594 mlog_bug_on_msg(end < offset + len, "Defrag check failed for " 3595 "bucket %llu\n", (unsigned long long)blkno); 3596 3597 end -= len; 3598 } 3599 3600 mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for " 3601 "bucket %llu\n", (unsigned long long)blkno); 3602 3603 if (xh_free_start == end) 3604 goto out; 3605 3606 memset(bucket_buf + xh_free_start, 0, end - xh_free_start); 3607 xh->xh_free_start = cpu_to_le16(end); 3608 3609 /* sort the entries by their name_hash. */ 3610 sort(entries, le16_to_cpu(xh->xh_count), 3611 sizeof(struct ocfs2_xattr_entry), 3612 cmp_xe, swap_xe); 3613 3614 buf = bucket_buf; 3615 for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize) 3616 memcpy(bucket_block(bucket, i), buf, blocksize); 3617 ocfs2_xattr_bucket_journal_dirty(handle, bucket); 3618 3619 out: 3620 kfree(bucket_buf); 3621 return ret; 3622 } 3623 3624 /* 3625 * prev_blkno points to the start of an existing extent. new_blkno 3626 * points to a newly allocated extent. Because we know each of our 3627 * clusters contains more than bucket, we can easily split one cluster 3628 * at a bucket boundary. So we take the last cluster of the existing 3629 * extent and split it down the middle. We move the last half of the 3630 * buckets in the last cluster of the existing extent over to the new 3631 * extent. 3632 * 3633 * first_bh is the buffer at prev_blkno so we can update the existing 3634 * extent's bucket count. header_bh is the bucket were we were hoping 3635 * to insert our xattr. If the bucket move places the target in the new 3636 * extent, we'll update first_bh and header_bh after modifying the old 3637 * extent. 3638 * 3639 * first_hash will be set as the 1st xe's name_hash in the new extent. 3640 */ 3641 static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode, 3642 handle_t *handle, 3643 struct ocfs2_xattr_bucket *first, 3644 struct ocfs2_xattr_bucket *target, 3645 u64 new_blkno, 3646 u32 num_clusters, 3647 u32 *first_hash) 3648 { 3649 int ret; 3650 struct super_block *sb = inode->i_sb; 3651 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb); 3652 int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb)); 3653 int to_move = num_buckets / 2; 3654 u64 src_blkno; 3655 u64 last_cluster_blkno = bucket_blkno(first) + 3656 ((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1)); 3657 3658 BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets); 3659 BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize); 3660 3661 mlog(0, "move half of xattrs in cluster %llu to %llu\n", 3662 (unsigned long long)last_cluster_blkno, (unsigned long long)new_blkno); 3663 3664 ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first), 3665 last_cluster_blkno, new_blkno, 3666 to_move, first_hash); 3667 if (ret) { 3668 mlog_errno(ret); 3669 goto out; 3670 } 3671 3672 /* This is the first bucket that got moved */ 3673 src_blkno = last_cluster_blkno + (to_move * blks_per_bucket); 3674 3675 /* 3676 * If the target bucket was part of the moved buckets, we need to 3677 * update first and target. 3678 */ 3679 if (bucket_blkno(target) >= src_blkno) { 3680 /* Find the block for the new target bucket */ 3681 src_blkno = new_blkno + 3682 (bucket_blkno(target) - src_blkno); 3683 3684 ocfs2_xattr_bucket_relse(first); 3685 ocfs2_xattr_bucket_relse(target); 3686 3687 /* 3688 * These shouldn't fail - the buffers are in the 3689 * journal from ocfs2_cp_xattr_bucket(). 3690 */ 3691 ret = ocfs2_read_xattr_bucket(first, new_blkno); 3692 if (ret) { 3693 mlog_errno(ret); 3694 goto out; 3695 } 3696 ret = ocfs2_read_xattr_bucket(target, src_blkno); 3697 if (ret) 3698 mlog_errno(ret); 3699 3700 } 3701 3702 out: 3703 return ret; 3704 } 3705 3706 /* 3707 * Find the suitable pos when we divide a bucket into 2. 3708 * We have to make sure the xattrs with the same hash value exist 3709 * in the same bucket. 3710 * 3711 * If this ocfs2_xattr_header covers more than one hash value, find a 3712 * place where the hash value changes. Try to find the most even split. 3713 * The most common case is that all entries have different hash values, 3714 * and the first check we make will find a place to split. 3715 */ 3716 static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header *xh) 3717 { 3718 struct ocfs2_xattr_entry *entries = xh->xh_entries; 3719 int count = le16_to_cpu(xh->xh_count); 3720 int delta, middle = count / 2; 3721 3722 /* 3723 * We start at the middle. Each step gets farther away in both 3724 * directions. We therefore hit the change in hash value 3725 * nearest to the middle. Note that this loop does not execute for 3726 * count < 2. 3727 */ 3728 for (delta = 0; delta < middle; delta++) { 3729 /* Let's check delta earlier than middle */ 3730 if (cmp_xe(&entries[middle - delta - 1], 3731 &entries[middle - delta])) 3732 return middle - delta; 3733 3734 /* For even counts, don't walk off the end */ 3735 if ((middle + delta + 1) == count) 3736 continue; 3737 3738 /* Now try delta past middle */ 3739 if (cmp_xe(&entries[middle + delta], 3740 &entries[middle + delta + 1])) 3741 return middle + delta + 1; 3742 } 3743 3744 /* Every entry had the same hash */ 3745 return count; 3746 } 3747 3748 /* 3749 * Move some xattrs in old bucket(blk) to new bucket(new_blk). 3750 * first_hash will record the 1st hash of the new bucket. 3751 * 3752 * Normally half of the xattrs will be moved. But we have to make 3753 * sure that the xattrs with the same hash value are stored in the 3754 * same bucket. If all the xattrs in this bucket have the same hash 3755 * value, the new bucket will be initialized as an empty one and the 3756 * first_hash will be initialized as (hash_value+1). 3757 */ 3758 static int ocfs2_divide_xattr_bucket(struct inode *inode, 3759 handle_t *handle, 3760 u64 blk, 3761 u64 new_blk, 3762 u32 *first_hash, 3763 int new_bucket_head) 3764 { 3765 int ret, i; 3766 int count, start, len, name_value_len = 0, xe_len, name_offset = 0; 3767 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL; 3768 struct ocfs2_xattr_header *xh; 3769 struct ocfs2_xattr_entry *xe; 3770 int blocksize = inode->i_sb->s_blocksize; 3771 3772 mlog(0, "move some of xattrs from bucket %llu to %llu\n", 3773 (unsigned long long)blk, (unsigned long long)new_blk); 3774 3775 s_bucket = ocfs2_xattr_bucket_new(inode); 3776 t_bucket = ocfs2_xattr_bucket_new(inode); 3777 if (!s_bucket || !t_bucket) { 3778 ret = -ENOMEM; 3779 mlog_errno(ret); 3780 goto out; 3781 } 3782 3783 ret = ocfs2_read_xattr_bucket(s_bucket, blk); 3784 if (ret) { 3785 mlog_errno(ret); 3786 goto out; 3787 } 3788 3789 ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket, 3790 OCFS2_JOURNAL_ACCESS_WRITE); 3791 if (ret) { 3792 mlog_errno(ret); 3793 goto out; 3794 } 3795 3796 /* 3797 * Even if !new_bucket_head, we're overwriting t_bucket. Thus, 3798 * there's no need to read it. 3799 */ 3800 ret = ocfs2_init_xattr_bucket(t_bucket, new_blk); 3801 if (ret) { 3802 mlog_errno(ret); 3803 goto out; 3804 } 3805 3806 /* 3807 * Hey, if we're overwriting t_bucket, what difference does 3808 * ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the 3809 * same part of ocfs2_cp_xattr_bucket(). 3810 */ 3811 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket, 3812 new_bucket_head ? 3813 OCFS2_JOURNAL_ACCESS_CREATE : 3814 OCFS2_JOURNAL_ACCESS_WRITE); 3815 if (ret) { 3816 mlog_errno(ret); 3817 goto out; 3818 } 3819 3820 xh = bucket_xh(s_bucket); 3821 count = le16_to_cpu(xh->xh_count); 3822 start = ocfs2_xattr_find_divide_pos(xh); 3823 3824 if (start == count) { 3825 xe = &xh->xh_entries[start-1]; 3826 3827 /* 3828 * initialized a new empty bucket here. 3829 * The hash value is set as one larger than 3830 * that of the last entry in the previous bucket. 3831 */ 3832 for (i = 0; i < t_bucket->bu_blocks; i++) 3833 memset(bucket_block(t_bucket, i), 0, blocksize); 3834 3835 xh = bucket_xh(t_bucket); 3836 xh->xh_free_start = cpu_to_le16(blocksize); 3837 xh->xh_entries[0].xe_name_hash = xe->xe_name_hash; 3838 le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1); 3839 3840 goto set_num_buckets; 3841 } 3842 3843 /* copy the whole bucket to the new first. */ 3844 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket); 3845 3846 /* update the new bucket. */ 3847 xh = bucket_xh(t_bucket); 3848 3849 /* 3850 * Calculate the total name/value len and xh_free_start for 3851 * the old bucket first. 3852 */ 3853 name_offset = OCFS2_XATTR_BUCKET_SIZE; 3854 name_value_len = 0; 3855 for (i = 0; i < start; i++) { 3856 xe = &xh->xh_entries[i]; 3857 xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3858 if (ocfs2_xattr_is_local(xe)) 3859 xe_len += 3860 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 3861 else 3862 xe_len += OCFS2_XATTR_ROOT_SIZE; 3863 name_value_len += xe_len; 3864 if (le16_to_cpu(xe->xe_name_offset) < name_offset) 3865 name_offset = le16_to_cpu(xe->xe_name_offset); 3866 } 3867 3868 /* 3869 * Now begin the modification to the new bucket. 3870 * 3871 * In the new bucket, We just move the xattr entry to the beginning 3872 * and don't touch the name/value. So there will be some holes in the 3873 * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is 3874 * called. 3875 */ 3876 xe = &xh->xh_entries[start]; 3877 len = sizeof(struct ocfs2_xattr_entry) * (count - start); 3878 mlog(0, "mv xattr entry len %d from %d to %d\n", len, 3879 (int)((char *)xe - (char *)xh), 3880 (int)((char *)xh->xh_entries - (char *)xh)); 3881 memmove((char *)xh->xh_entries, (char *)xe, len); 3882 xe = &xh->xh_entries[count - start]; 3883 len = sizeof(struct ocfs2_xattr_entry) * start; 3884 memset((char *)xe, 0, len); 3885 3886 le16_add_cpu(&xh->xh_count, -start); 3887 le16_add_cpu(&xh->xh_name_value_len, -name_value_len); 3888 3889 /* Calculate xh_free_start for the new bucket. */ 3890 xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE); 3891 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 3892 xe = &xh->xh_entries[i]; 3893 xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len); 3894 if (ocfs2_xattr_is_local(xe)) 3895 xe_len += 3896 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 3897 else 3898 xe_len += OCFS2_XATTR_ROOT_SIZE; 3899 if (le16_to_cpu(xe->xe_name_offset) < 3900 le16_to_cpu(xh->xh_free_start)) 3901 xh->xh_free_start = xe->xe_name_offset; 3902 } 3903 3904 set_num_buckets: 3905 /* set xh->xh_num_buckets for the new xh. */ 3906 if (new_bucket_head) 3907 xh->xh_num_buckets = cpu_to_le16(1); 3908 else 3909 xh->xh_num_buckets = 0; 3910 3911 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket); 3912 3913 /* store the first_hash of the new bucket. */ 3914 if (first_hash) 3915 *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash); 3916 3917 /* 3918 * Now only update the 1st block of the old bucket. If we 3919 * just added a new empty bucket, there is no need to modify 3920 * it. 3921 */ 3922 if (start == count) 3923 goto out; 3924 3925 xh = bucket_xh(s_bucket); 3926 memset(&xh->xh_entries[start], 0, 3927 sizeof(struct ocfs2_xattr_entry) * (count - start)); 3928 xh->xh_count = cpu_to_le16(start); 3929 xh->xh_free_start = cpu_to_le16(name_offset); 3930 xh->xh_name_value_len = cpu_to_le16(name_value_len); 3931 3932 ocfs2_xattr_bucket_journal_dirty(handle, s_bucket); 3933 3934 out: 3935 ocfs2_xattr_bucket_free(s_bucket); 3936 ocfs2_xattr_bucket_free(t_bucket); 3937 3938 return ret; 3939 } 3940 3941 /* 3942 * Copy xattr from one bucket to another bucket. 3943 * 3944 * The caller must make sure that the journal transaction 3945 * has enough space for journaling. 3946 */ 3947 static int ocfs2_cp_xattr_bucket(struct inode *inode, 3948 handle_t *handle, 3949 u64 s_blkno, 3950 u64 t_blkno, 3951 int t_is_new) 3952 { 3953 int ret; 3954 struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL; 3955 3956 BUG_ON(s_blkno == t_blkno); 3957 3958 mlog(0, "cp bucket %llu to %llu, target is %d\n", 3959 (unsigned long long)s_blkno, (unsigned long long)t_blkno, 3960 t_is_new); 3961 3962 s_bucket = ocfs2_xattr_bucket_new(inode); 3963 t_bucket = ocfs2_xattr_bucket_new(inode); 3964 if (!s_bucket || !t_bucket) { 3965 ret = -ENOMEM; 3966 mlog_errno(ret); 3967 goto out; 3968 } 3969 3970 ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno); 3971 if (ret) 3972 goto out; 3973 3974 /* 3975 * Even if !t_is_new, we're overwriting t_bucket. Thus, 3976 * there's no need to read it. 3977 */ 3978 ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno); 3979 if (ret) 3980 goto out; 3981 3982 /* 3983 * Hey, if we're overwriting t_bucket, what difference does 3984 * ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new 3985 * cluster to fill, we came here from 3986 * ocfs2_mv_xattr_buckets(), and it is really new - 3987 * ACCESS_CREATE is required. But we also might have moved data 3988 * out of t_bucket before extending back into it. 3989 * ocfs2_add_new_xattr_bucket() can do this - its call to 3990 * ocfs2_add_new_xattr_cluster() may have created a new extent 3991 * and copied out the end of the old extent. Then it re-extends 3992 * the old extent back to create space for new xattrs. That's 3993 * how we get here, and the bucket isn't really new. 3994 */ 3995 ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket, 3996 t_is_new ? 3997 OCFS2_JOURNAL_ACCESS_CREATE : 3998 OCFS2_JOURNAL_ACCESS_WRITE); 3999 if (ret) 4000 goto out; 4001 4002 ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket); 4003 ocfs2_xattr_bucket_journal_dirty(handle, t_bucket); 4004 4005 out: 4006 ocfs2_xattr_bucket_free(t_bucket); 4007 ocfs2_xattr_bucket_free(s_bucket); 4008 4009 return ret; 4010 } 4011 4012 /* 4013 * src_blk points to the start of an existing extent. last_blk points to 4014 * last cluster in that extent. to_blk points to a newly allocated 4015 * extent. We copy the buckets from the cluster at last_blk to the new 4016 * extent. If start_bucket is non-zero, we skip that many buckets before 4017 * we start copying. The new extent's xh_num_buckets gets set to the 4018 * number of buckets we copied. The old extent's xh_num_buckets shrinks 4019 * by the same amount. 4020 */ 4021 static int ocfs2_mv_xattr_buckets(struct inode *inode, handle_t *handle, 4022 u64 src_blk, u64 last_blk, u64 to_blk, 4023 unsigned int start_bucket, 4024 u32 *first_hash) 4025 { 4026 int i, ret, credits; 4027 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4028 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4029 int num_buckets = ocfs2_xattr_buckets_per_cluster(osb); 4030 struct ocfs2_xattr_bucket *old_first, *new_first; 4031 4032 mlog(0, "mv xattrs from cluster %llu to %llu\n", 4033 (unsigned long long)last_blk, (unsigned long long)to_blk); 4034 4035 BUG_ON(start_bucket >= num_buckets); 4036 if (start_bucket) { 4037 num_buckets -= start_bucket; 4038 last_blk += (start_bucket * blks_per_bucket); 4039 } 4040 4041 /* The first bucket of the original extent */ 4042 old_first = ocfs2_xattr_bucket_new(inode); 4043 /* The first bucket of the new extent */ 4044 new_first = ocfs2_xattr_bucket_new(inode); 4045 if (!old_first || !new_first) { 4046 ret = -ENOMEM; 4047 mlog_errno(ret); 4048 goto out; 4049 } 4050 4051 ret = ocfs2_read_xattr_bucket(old_first, src_blk); 4052 if (ret) { 4053 mlog_errno(ret); 4054 goto out; 4055 } 4056 4057 /* 4058 * We need to update the first bucket of the old extent and all 4059 * the buckets going to the new extent. 4060 */ 4061 credits = ((num_buckets + 1) * blks_per_bucket) + 4062 handle->h_buffer_credits; 4063 ret = ocfs2_extend_trans(handle, credits); 4064 if (ret) { 4065 mlog_errno(ret); 4066 goto out; 4067 } 4068 4069 ret = ocfs2_xattr_bucket_journal_access(handle, old_first, 4070 OCFS2_JOURNAL_ACCESS_WRITE); 4071 if (ret) { 4072 mlog_errno(ret); 4073 goto out; 4074 } 4075 4076 for (i = 0; i < num_buckets; i++) { 4077 ret = ocfs2_cp_xattr_bucket(inode, handle, 4078 last_blk + (i * blks_per_bucket), 4079 to_blk + (i * blks_per_bucket), 4080 1); 4081 if (ret) { 4082 mlog_errno(ret); 4083 goto out; 4084 } 4085 } 4086 4087 /* 4088 * Get the new bucket ready before we dirty anything 4089 * (This actually shouldn't fail, because we already dirtied 4090 * it once in ocfs2_cp_xattr_bucket()). 4091 */ 4092 ret = ocfs2_read_xattr_bucket(new_first, to_blk); 4093 if (ret) { 4094 mlog_errno(ret); 4095 goto out; 4096 } 4097 ret = ocfs2_xattr_bucket_journal_access(handle, new_first, 4098 OCFS2_JOURNAL_ACCESS_WRITE); 4099 if (ret) { 4100 mlog_errno(ret); 4101 goto out; 4102 } 4103 4104 /* Now update the headers */ 4105 le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets); 4106 ocfs2_xattr_bucket_journal_dirty(handle, old_first); 4107 4108 bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets); 4109 ocfs2_xattr_bucket_journal_dirty(handle, new_first); 4110 4111 if (first_hash) 4112 *first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash); 4113 4114 out: 4115 ocfs2_xattr_bucket_free(new_first); 4116 ocfs2_xattr_bucket_free(old_first); 4117 return ret; 4118 } 4119 4120 /* 4121 * Move some xattrs in this cluster to the new cluster. 4122 * This function should only be called when bucket size == cluster size. 4123 * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead. 4124 */ 4125 static int ocfs2_divide_xattr_cluster(struct inode *inode, 4126 handle_t *handle, 4127 u64 prev_blk, 4128 u64 new_blk, 4129 u32 *first_hash) 4130 { 4131 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4132 int ret, credits = 2 * blk_per_bucket + handle->h_buffer_credits; 4133 4134 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize); 4135 4136 ret = ocfs2_extend_trans(handle, credits); 4137 if (ret) { 4138 mlog_errno(ret); 4139 return ret; 4140 } 4141 4142 /* Move half of the xattr in start_blk to the next bucket. */ 4143 return ocfs2_divide_xattr_bucket(inode, handle, prev_blk, 4144 new_blk, first_hash, 1); 4145 } 4146 4147 /* 4148 * Move some xattrs from the old cluster to the new one since they are not 4149 * contiguous in ocfs2 xattr tree. 4150 * 4151 * new_blk starts a new separate cluster, and we will move some xattrs from 4152 * prev_blk to it. v_start will be set as the first name hash value in this 4153 * new cluster so that it can be used as e_cpos during tree insertion and 4154 * don't collide with our original b-tree operations. first_bh and header_bh 4155 * will also be updated since they will be used in ocfs2_extend_xattr_bucket 4156 * to extend the insert bucket. 4157 * 4158 * The problem is how much xattr should we move to the new one and when should 4159 * we update first_bh and header_bh? 4160 * 1. If cluster size > bucket size, that means the previous cluster has more 4161 * than 1 bucket, so just move half nums of bucket into the new cluster and 4162 * update the first_bh and header_bh if the insert bucket has been moved 4163 * to the new cluster. 4164 * 2. If cluster_size == bucket_size: 4165 * a) If the previous extent rec has more than one cluster and the insert 4166 * place isn't in the last cluster, copy the entire last cluster to the 4167 * new one. This time, we don't need to upate the first_bh and header_bh 4168 * since they will not be moved into the new cluster. 4169 * b) Otherwise, move the bottom half of the xattrs in the last cluster into 4170 * the new one. And we set the extend flag to zero if the insert place is 4171 * moved into the new allocated cluster since no extend is needed. 4172 */ 4173 static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode, 4174 handle_t *handle, 4175 struct ocfs2_xattr_bucket *first, 4176 struct ocfs2_xattr_bucket *target, 4177 u64 new_blk, 4178 u32 prev_clusters, 4179 u32 *v_start, 4180 int *extend) 4181 { 4182 int ret; 4183 4184 mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n", 4185 (unsigned long long)bucket_blkno(first), prev_clusters, 4186 (unsigned long long)new_blk); 4187 4188 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) { 4189 ret = ocfs2_mv_xattr_bucket_cross_cluster(inode, 4190 handle, 4191 first, target, 4192 new_blk, 4193 prev_clusters, 4194 v_start); 4195 if (ret) 4196 mlog_errno(ret); 4197 } else { 4198 /* The start of the last cluster in the first extent */ 4199 u64 last_blk = bucket_blkno(first) + 4200 ((prev_clusters - 1) * 4201 ocfs2_clusters_to_blocks(inode->i_sb, 1)); 4202 4203 if (prev_clusters > 1 && bucket_blkno(target) != last_blk) { 4204 ret = ocfs2_mv_xattr_buckets(inode, handle, 4205 bucket_blkno(first), 4206 last_blk, new_blk, 0, 4207 v_start); 4208 if (ret) 4209 mlog_errno(ret); 4210 } else { 4211 ret = ocfs2_divide_xattr_cluster(inode, handle, 4212 last_blk, new_blk, 4213 v_start); 4214 if (ret) 4215 mlog_errno(ret); 4216 4217 if ((bucket_blkno(target) == last_blk) && extend) 4218 *extend = 0; 4219 } 4220 } 4221 4222 return ret; 4223 } 4224 4225 /* 4226 * Add a new cluster for xattr storage. 4227 * 4228 * If the new cluster is contiguous with the previous one, it will be 4229 * appended to the same extent record, and num_clusters will be updated. 4230 * If not, we will insert a new extent for it and move some xattrs in 4231 * the last cluster into the new allocated one. 4232 * We also need to limit the maximum size of a btree leaf, otherwise we'll 4233 * lose the benefits of hashing because we'll have to search large leaves. 4234 * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize, 4235 * if it's bigger). 4236 * 4237 * first_bh is the first block of the previous extent rec and header_bh 4238 * indicates the bucket we will insert the new xattrs. They will be updated 4239 * when the header_bh is moved into the new cluster. 4240 */ 4241 static int ocfs2_add_new_xattr_cluster(struct inode *inode, 4242 struct buffer_head *root_bh, 4243 struct ocfs2_xattr_bucket *first, 4244 struct ocfs2_xattr_bucket *target, 4245 u32 *num_clusters, 4246 u32 prev_cpos, 4247 int *extend, 4248 struct ocfs2_xattr_set_ctxt *ctxt) 4249 { 4250 int ret; 4251 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 4252 u32 prev_clusters = *num_clusters; 4253 u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0; 4254 u64 block; 4255 handle_t *handle = ctxt->handle; 4256 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4257 struct ocfs2_extent_tree et; 4258 4259 mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, " 4260 "previous xattr blkno = %llu\n", 4261 (unsigned long long)OCFS2_I(inode)->ip_blkno, 4262 prev_cpos, (unsigned long long)bucket_blkno(first)); 4263 4264 ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh); 4265 4266 ret = ocfs2_journal_access_xb(handle, inode, root_bh, 4267 OCFS2_JOURNAL_ACCESS_WRITE); 4268 if (ret < 0) { 4269 mlog_errno(ret); 4270 goto leave; 4271 } 4272 4273 ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 1, 4274 clusters_to_add, &bit_off, &num_bits); 4275 if (ret < 0) { 4276 if (ret != -ENOSPC) 4277 mlog_errno(ret); 4278 goto leave; 4279 } 4280 4281 BUG_ON(num_bits > clusters_to_add); 4282 4283 block = ocfs2_clusters_to_blocks(osb->sb, bit_off); 4284 mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n", 4285 num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno); 4286 4287 if (bucket_blkno(first) + (prev_clusters * bpc) == block && 4288 (prev_clusters + num_bits) << osb->s_clustersize_bits <= 4289 OCFS2_MAX_XATTR_TREE_LEAF_SIZE) { 4290 /* 4291 * If this cluster is contiguous with the old one and 4292 * adding this new cluster, we don't surpass the limit of 4293 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be 4294 * initialized and used like other buckets in the previous 4295 * cluster. 4296 * So add it as a contiguous one. The caller will handle 4297 * its init process. 4298 */ 4299 v_start = prev_cpos + prev_clusters; 4300 *num_clusters = prev_clusters + num_bits; 4301 mlog(0, "Add contiguous %u clusters to previous extent rec.\n", 4302 num_bits); 4303 } else { 4304 ret = ocfs2_adjust_xattr_cross_cluster(inode, 4305 handle, 4306 first, 4307 target, 4308 block, 4309 prev_clusters, 4310 &v_start, 4311 extend); 4312 if (ret) { 4313 mlog_errno(ret); 4314 goto leave; 4315 } 4316 } 4317 4318 mlog(0, "Insert %u clusters at block %llu for xattr at %u\n", 4319 num_bits, (unsigned long long)block, v_start); 4320 ret = ocfs2_insert_extent(osb, handle, inode, &et, v_start, block, 4321 num_bits, 0, ctxt->meta_ac); 4322 if (ret < 0) { 4323 mlog_errno(ret); 4324 goto leave; 4325 } 4326 4327 ret = ocfs2_journal_dirty(handle, root_bh); 4328 if (ret < 0) 4329 mlog_errno(ret); 4330 4331 leave: 4332 return ret; 4333 } 4334 4335 /* 4336 * We are given an extent. 'first' is the bucket at the very front of 4337 * the extent. The extent has space for an additional bucket past 4338 * bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number 4339 * of the target bucket. We wish to shift every bucket past the target 4340 * down one, filling in that additional space. When we get back to the 4341 * target, we split the target between itself and the now-empty bucket 4342 * at target+1 (aka, target_blkno + blks_per_bucket). 4343 */ 4344 static int ocfs2_extend_xattr_bucket(struct inode *inode, 4345 handle_t *handle, 4346 struct ocfs2_xattr_bucket *first, 4347 u64 target_blk, 4348 u32 num_clusters) 4349 { 4350 int ret, credits; 4351 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4352 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); 4353 u64 end_blk; 4354 u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets); 4355 4356 mlog(0, "extend xattr bucket in %llu, xattr extend rec starting " 4357 "from %llu, len = %u\n", (unsigned long long)target_blk, 4358 (unsigned long long)bucket_blkno(first), num_clusters); 4359 4360 /* The extent must have room for an additional bucket */ 4361 BUG_ON(new_bucket >= 4362 (num_clusters * ocfs2_xattr_buckets_per_cluster(osb))); 4363 4364 /* end_blk points to the last existing bucket */ 4365 end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket); 4366 4367 /* 4368 * end_blk is the start of the last existing bucket. 4369 * Thus, (end_blk - target_blk) covers the target bucket and 4370 * every bucket after it up to, but not including, the last 4371 * existing bucket. Then we add the last existing bucket, the 4372 * new bucket, and the first bucket (3 * blk_per_bucket). 4373 */ 4374 credits = (end_blk - target_blk) + (3 * blk_per_bucket) + 4375 handle->h_buffer_credits; 4376 ret = ocfs2_extend_trans(handle, credits); 4377 if (ret) { 4378 mlog_errno(ret); 4379 goto out; 4380 } 4381 4382 ret = ocfs2_xattr_bucket_journal_access(handle, first, 4383 OCFS2_JOURNAL_ACCESS_WRITE); 4384 if (ret) { 4385 mlog_errno(ret); 4386 goto out; 4387 } 4388 4389 while (end_blk != target_blk) { 4390 ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk, 4391 end_blk + blk_per_bucket, 0); 4392 if (ret) 4393 goto out; 4394 end_blk -= blk_per_bucket; 4395 } 4396 4397 /* Move half of the xattr in target_blkno to the next bucket. */ 4398 ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk, 4399 target_blk + blk_per_bucket, NULL, 0); 4400 4401 le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1); 4402 ocfs2_xattr_bucket_journal_dirty(handle, first); 4403 4404 out: 4405 return ret; 4406 } 4407 4408 /* 4409 * Add new xattr bucket in an extent record and adjust the buckets 4410 * accordingly. xb_bh is the ocfs2_xattr_block, and target is the 4411 * bucket we want to insert into. 4412 * 4413 * In the easy case, we will move all the buckets after target down by 4414 * one. Half of target's xattrs will be moved to the next bucket. 4415 * 4416 * If current cluster is full, we'll allocate a new one. This may not 4417 * be contiguous. The underlying calls will make sure that there is 4418 * space for the insert, shifting buckets around if necessary. 4419 * 'target' may be moved by those calls. 4420 */ 4421 static int ocfs2_add_new_xattr_bucket(struct inode *inode, 4422 struct buffer_head *xb_bh, 4423 struct ocfs2_xattr_bucket *target, 4424 struct ocfs2_xattr_set_ctxt *ctxt) 4425 { 4426 struct ocfs2_xattr_block *xb = 4427 (struct ocfs2_xattr_block *)xb_bh->b_data; 4428 struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root; 4429 struct ocfs2_extent_list *el = &xb_root->xt_list; 4430 u32 name_hash = 4431 le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash); 4432 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4433 int ret, num_buckets, extend = 1; 4434 u64 p_blkno; 4435 u32 e_cpos, num_clusters; 4436 /* The bucket at the front of the extent */ 4437 struct ocfs2_xattr_bucket *first; 4438 4439 mlog(0, "Add new xattr bucket starting from %llu\n", 4440 (unsigned long long)bucket_blkno(target)); 4441 4442 /* The first bucket of the original extent */ 4443 first = ocfs2_xattr_bucket_new(inode); 4444 if (!first) { 4445 ret = -ENOMEM; 4446 mlog_errno(ret); 4447 goto out; 4448 } 4449 4450 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos, 4451 &num_clusters, el); 4452 if (ret) { 4453 mlog_errno(ret); 4454 goto out; 4455 } 4456 4457 ret = ocfs2_read_xattr_bucket(first, p_blkno); 4458 if (ret) { 4459 mlog_errno(ret); 4460 goto out; 4461 } 4462 4463 num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters; 4464 if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) { 4465 /* 4466 * This can move first+target if the target bucket moves 4467 * to the new extent. 4468 */ 4469 ret = ocfs2_add_new_xattr_cluster(inode, 4470 xb_bh, 4471 first, 4472 target, 4473 &num_clusters, 4474 e_cpos, 4475 &extend, 4476 ctxt); 4477 if (ret) { 4478 mlog_errno(ret); 4479 goto out; 4480 } 4481 } 4482 4483 if (extend) { 4484 ret = ocfs2_extend_xattr_bucket(inode, 4485 ctxt->handle, 4486 first, 4487 bucket_blkno(target), 4488 num_clusters); 4489 if (ret) 4490 mlog_errno(ret); 4491 } 4492 4493 out: 4494 ocfs2_xattr_bucket_free(first); 4495 4496 return ret; 4497 } 4498 4499 static inline char *ocfs2_xattr_bucket_get_val(struct inode *inode, 4500 struct ocfs2_xattr_bucket *bucket, 4501 int offs) 4502 { 4503 int block_off = offs >> inode->i_sb->s_blocksize_bits; 4504 4505 offs = offs % inode->i_sb->s_blocksize; 4506 return bucket_block(bucket, block_off) + offs; 4507 } 4508 4509 /* 4510 * Handle the normal xattr set, including replace, delete and new. 4511 * 4512 * Note: "local" indicates the real data's locality. So we can't 4513 * just its bucket locality by its length. 4514 */ 4515 static void ocfs2_xattr_set_entry_normal(struct inode *inode, 4516 struct ocfs2_xattr_info *xi, 4517 struct ocfs2_xattr_search *xs, 4518 u32 name_hash, 4519 int local) 4520 { 4521 struct ocfs2_xattr_entry *last, *xe; 4522 int name_len = strlen(xi->name); 4523 struct ocfs2_xattr_header *xh = xs->header; 4524 u16 count = le16_to_cpu(xh->xh_count), start; 4525 size_t blocksize = inode->i_sb->s_blocksize; 4526 char *val; 4527 size_t offs, size, new_size; 4528 4529 last = &xh->xh_entries[count]; 4530 if (!xs->not_found) { 4531 xe = xs->here; 4532 offs = le16_to_cpu(xe->xe_name_offset); 4533 if (ocfs2_xattr_is_local(xe)) 4534 size = OCFS2_XATTR_SIZE(name_len) + 4535 OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 4536 else 4537 size = OCFS2_XATTR_SIZE(name_len) + 4538 OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE); 4539 4540 /* 4541 * If the new value will be stored outside, xi->value has been 4542 * initalized as an empty ocfs2_xattr_value_root, and the same 4543 * goes with xi->value_len, so we can set new_size safely here. 4544 * See ocfs2_xattr_set_in_bucket. 4545 */ 4546 new_size = OCFS2_XATTR_SIZE(name_len) + 4547 OCFS2_XATTR_SIZE(xi->value_len); 4548 4549 le16_add_cpu(&xh->xh_name_value_len, -size); 4550 if (xi->value) { 4551 if (new_size > size) 4552 goto set_new_name_value; 4553 4554 /* Now replace the old value with new one. */ 4555 if (local) 4556 xe->xe_value_size = cpu_to_le64(xi->value_len); 4557 else 4558 xe->xe_value_size = 0; 4559 4560 val = ocfs2_xattr_bucket_get_val(inode, 4561 xs->bucket, offs); 4562 memset(val + OCFS2_XATTR_SIZE(name_len), 0, 4563 size - OCFS2_XATTR_SIZE(name_len)); 4564 if (OCFS2_XATTR_SIZE(xi->value_len) > 0) 4565 memcpy(val + OCFS2_XATTR_SIZE(name_len), 4566 xi->value, xi->value_len); 4567 4568 le16_add_cpu(&xh->xh_name_value_len, new_size); 4569 ocfs2_xattr_set_local(xe, local); 4570 return; 4571 } else { 4572 /* 4573 * Remove the old entry if there is more than one. 4574 * We don't remove the last entry so that we can 4575 * use it to indicate the hash value of the empty 4576 * bucket. 4577 */ 4578 last -= 1; 4579 le16_add_cpu(&xh->xh_count, -1); 4580 if (xh->xh_count) { 4581 memmove(xe, xe + 1, 4582 (void *)last - (void *)xe); 4583 memset(last, 0, 4584 sizeof(struct ocfs2_xattr_entry)); 4585 } else 4586 xh->xh_free_start = 4587 cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE); 4588 4589 return; 4590 } 4591 } else { 4592 /* find a new entry for insert. */ 4593 int low = 0, high = count - 1, tmp; 4594 struct ocfs2_xattr_entry *tmp_xe; 4595 4596 while (low <= high && count) { 4597 tmp = (low + high) / 2; 4598 tmp_xe = &xh->xh_entries[tmp]; 4599 4600 if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash)) 4601 low = tmp + 1; 4602 else if (name_hash < 4603 le32_to_cpu(tmp_xe->xe_name_hash)) 4604 high = tmp - 1; 4605 else { 4606 low = tmp; 4607 break; 4608 } 4609 } 4610 4611 xe = &xh->xh_entries[low]; 4612 if (low != count) 4613 memmove(xe + 1, xe, (void *)last - (void *)xe); 4614 4615 le16_add_cpu(&xh->xh_count, 1); 4616 memset(xe, 0, sizeof(struct ocfs2_xattr_entry)); 4617 xe->xe_name_hash = cpu_to_le32(name_hash); 4618 xe->xe_name_len = name_len; 4619 ocfs2_xattr_set_type(xe, xi->name_index); 4620 } 4621 4622 set_new_name_value: 4623 /* Insert the new name+value. */ 4624 size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(xi->value_len); 4625 4626 /* 4627 * We must make sure that the name/value pair 4628 * exists in the same block. 4629 */ 4630 offs = le16_to_cpu(xh->xh_free_start); 4631 start = offs - size; 4632 4633 if (start >> inode->i_sb->s_blocksize_bits != 4634 (offs - 1) >> inode->i_sb->s_blocksize_bits) { 4635 offs = offs - offs % blocksize; 4636 xh->xh_free_start = cpu_to_le16(offs); 4637 } 4638 4639 val = ocfs2_xattr_bucket_get_val(inode, xs->bucket, offs - size); 4640 xe->xe_name_offset = cpu_to_le16(offs - size); 4641 4642 memset(val, 0, size); 4643 memcpy(val, xi->name, name_len); 4644 memcpy(val + OCFS2_XATTR_SIZE(name_len), xi->value, xi->value_len); 4645 4646 xe->xe_value_size = cpu_to_le64(xi->value_len); 4647 ocfs2_xattr_set_local(xe, local); 4648 xs->here = xe; 4649 le16_add_cpu(&xh->xh_free_start, -size); 4650 le16_add_cpu(&xh->xh_name_value_len, size); 4651 4652 return; 4653 } 4654 4655 /* 4656 * Set the xattr entry in the specified bucket. 4657 * The bucket is indicated by xs->bucket and it should have the enough 4658 * space for the xattr insertion. 4659 */ 4660 static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode, 4661 handle_t *handle, 4662 struct ocfs2_xattr_info *xi, 4663 struct ocfs2_xattr_search *xs, 4664 u32 name_hash, 4665 int local) 4666 { 4667 int ret; 4668 u64 blkno; 4669 4670 mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n", 4671 (unsigned long)xi->value_len, xi->name_index, 4672 (unsigned long long)bucket_blkno(xs->bucket)); 4673 4674 if (!xs->bucket->bu_bhs[1]) { 4675 blkno = bucket_blkno(xs->bucket); 4676 ocfs2_xattr_bucket_relse(xs->bucket); 4677 ret = ocfs2_read_xattr_bucket(xs->bucket, blkno); 4678 if (ret) { 4679 mlog_errno(ret); 4680 goto out; 4681 } 4682 } 4683 4684 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket, 4685 OCFS2_JOURNAL_ACCESS_WRITE); 4686 if (ret < 0) { 4687 mlog_errno(ret); 4688 goto out; 4689 } 4690 4691 ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local); 4692 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket); 4693 4694 out: 4695 return ret; 4696 } 4697 4698 /* 4699 * Truncate the specified xe_off entry in xattr bucket. 4700 * bucket is indicated by header_bh and len is the new length. 4701 * Both the ocfs2_xattr_value_root and the entry will be updated here. 4702 * 4703 * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed. 4704 */ 4705 static int ocfs2_xattr_bucket_value_truncate(struct inode *inode, 4706 struct ocfs2_xattr_bucket *bucket, 4707 int xe_off, 4708 int len, 4709 struct ocfs2_xattr_set_ctxt *ctxt) 4710 { 4711 int ret, offset; 4712 u64 value_blk; 4713 struct ocfs2_xattr_entry *xe; 4714 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 4715 size_t blocksize = inode->i_sb->s_blocksize; 4716 struct ocfs2_xattr_value_buf vb = { 4717 .vb_access = ocfs2_journal_access, 4718 }; 4719 4720 xe = &xh->xh_entries[xe_off]; 4721 4722 BUG_ON(!xe || ocfs2_xattr_is_local(xe)); 4723 4724 offset = le16_to_cpu(xe->xe_name_offset) + 4725 OCFS2_XATTR_SIZE(xe->xe_name_len); 4726 4727 value_blk = offset / blocksize; 4728 4729 /* We don't allow ocfs2_xattr_value to be stored in different block. */ 4730 BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize); 4731 4732 vb.vb_bh = bucket->bu_bhs[value_blk]; 4733 BUG_ON(!vb.vb_bh); 4734 4735 vb.vb_xv = (struct ocfs2_xattr_value_root *) 4736 (vb.vb_bh->b_data + offset % blocksize); 4737 4738 /* 4739 * From here on out we have to dirty the bucket. The generic 4740 * value calls only modify one of the bucket's bhs, but we need 4741 * to send the bucket at once. So if they error, they *could* have 4742 * modified something. We have to assume they did, and dirty 4743 * the whole bucket. This leaves us in a consistent state. 4744 */ 4745 mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n", 4746 xe_off, (unsigned long long)bucket_blkno(bucket), len); 4747 ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt); 4748 if (ret) { 4749 mlog_errno(ret); 4750 goto out; 4751 } 4752 4753 ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket, 4754 OCFS2_JOURNAL_ACCESS_WRITE); 4755 if (ret) { 4756 mlog_errno(ret); 4757 goto out; 4758 } 4759 4760 xe->xe_value_size = cpu_to_le64(len); 4761 4762 ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket); 4763 4764 out: 4765 return ret; 4766 } 4767 4768 static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode, 4769 struct ocfs2_xattr_search *xs, 4770 int len, 4771 struct ocfs2_xattr_set_ctxt *ctxt) 4772 { 4773 int ret, offset; 4774 struct ocfs2_xattr_entry *xe = xs->here; 4775 struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base; 4776 4777 BUG_ON(!xs->bucket->bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe)); 4778 4779 offset = xe - xh->xh_entries; 4780 ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket, 4781 offset, len, ctxt); 4782 if (ret) 4783 mlog_errno(ret); 4784 4785 return ret; 4786 } 4787 4788 static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode, 4789 handle_t *handle, 4790 struct ocfs2_xattr_search *xs, 4791 char *val, 4792 int value_len) 4793 { 4794 int ret, offset, block_off; 4795 struct ocfs2_xattr_value_root *xv; 4796 struct ocfs2_xattr_entry *xe = xs->here; 4797 struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket); 4798 void *base; 4799 4800 BUG_ON(!xs->base || !xe || ocfs2_xattr_is_local(xe)); 4801 4802 ret = ocfs2_xattr_bucket_get_name_value(inode, xh, 4803 xe - xh->xh_entries, 4804 &block_off, 4805 &offset); 4806 if (ret) { 4807 mlog_errno(ret); 4808 goto out; 4809 } 4810 4811 base = bucket_block(xs->bucket, block_off); 4812 xv = (struct ocfs2_xattr_value_root *)(base + offset + 4813 OCFS2_XATTR_SIZE(xe->xe_name_len)); 4814 4815 ret = __ocfs2_xattr_set_value_outside(inode, handle, 4816 xv, val, value_len); 4817 if (ret) 4818 mlog_errno(ret); 4819 out: 4820 return ret; 4821 } 4822 4823 static int ocfs2_rm_xattr_cluster(struct inode *inode, 4824 struct buffer_head *root_bh, 4825 u64 blkno, 4826 u32 cpos, 4827 u32 len) 4828 { 4829 int ret; 4830 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 4831 struct inode *tl_inode = osb->osb_tl_inode; 4832 handle_t *handle; 4833 struct ocfs2_xattr_block *xb = 4834 (struct ocfs2_xattr_block *)root_bh->b_data; 4835 struct ocfs2_alloc_context *meta_ac = NULL; 4836 struct ocfs2_cached_dealloc_ctxt dealloc; 4837 struct ocfs2_extent_tree et; 4838 4839 ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh); 4840 4841 ocfs2_init_dealloc_ctxt(&dealloc); 4842 4843 mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n", 4844 cpos, len, (unsigned long long)blkno); 4845 4846 ocfs2_remove_xattr_clusters_from_cache(inode, blkno, len); 4847 4848 ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac); 4849 if (ret) { 4850 mlog_errno(ret); 4851 return ret; 4852 } 4853 4854 mutex_lock(&tl_inode->i_mutex); 4855 4856 if (ocfs2_truncate_log_needs_flush(osb)) { 4857 ret = __ocfs2_flush_truncate_log(osb); 4858 if (ret < 0) { 4859 mlog_errno(ret); 4860 goto out; 4861 } 4862 } 4863 4864 handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb)); 4865 if (IS_ERR(handle)) { 4866 ret = -ENOMEM; 4867 mlog_errno(ret); 4868 goto out; 4869 } 4870 4871 ret = ocfs2_journal_access_xb(handle, inode, root_bh, 4872 OCFS2_JOURNAL_ACCESS_WRITE); 4873 if (ret) { 4874 mlog_errno(ret); 4875 goto out_commit; 4876 } 4877 4878 ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac, 4879 &dealloc); 4880 if (ret) { 4881 mlog_errno(ret); 4882 goto out_commit; 4883 } 4884 4885 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len); 4886 4887 ret = ocfs2_journal_dirty(handle, root_bh); 4888 if (ret) { 4889 mlog_errno(ret); 4890 goto out_commit; 4891 } 4892 4893 ret = ocfs2_truncate_log_append(osb, handle, blkno, len); 4894 if (ret) 4895 mlog_errno(ret); 4896 4897 out_commit: 4898 ocfs2_commit_trans(osb, handle); 4899 out: 4900 ocfs2_schedule_truncate_log_flush(osb, 1); 4901 4902 mutex_unlock(&tl_inode->i_mutex); 4903 4904 if (meta_ac) 4905 ocfs2_free_alloc_context(meta_ac); 4906 4907 ocfs2_run_deallocs(osb, &dealloc); 4908 4909 return ret; 4910 } 4911 4912 static void ocfs2_xattr_bucket_remove_xs(struct inode *inode, 4913 handle_t *handle, 4914 struct ocfs2_xattr_search *xs) 4915 { 4916 struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket); 4917 struct ocfs2_xattr_entry *last = &xh->xh_entries[ 4918 le16_to_cpu(xh->xh_count) - 1]; 4919 int ret = 0; 4920 4921 ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket, 4922 OCFS2_JOURNAL_ACCESS_WRITE); 4923 if (ret) { 4924 mlog_errno(ret); 4925 return; 4926 } 4927 4928 /* Remove the old entry. */ 4929 memmove(xs->here, xs->here + 1, 4930 (void *)last - (void *)xs->here); 4931 memset(last, 0, sizeof(struct ocfs2_xattr_entry)); 4932 le16_add_cpu(&xh->xh_count, -1); 4933 4934 ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket); 4935 } 4936 4937 /* 4938 * Set the xattr name/value in the bucket specified in xs. 4939 * 4940 * As the new value in xi may be stored in the bucket or in an outside cluster, 4941 * we divide the whole process into 3 steps: 4942 * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket) 4943 * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs) 4944 * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside) 4945 * 4. If the clusters for the new outside value can't be allocated, we need 4946 * to free the xattr we allocated in set. 4947 */ 4948 static int ocfs2_xattr_set_in_bucket(struct inode *inode, 4949 struct ocfs2_xattr_info *xi, 4950 struct ocfs2_xattr_search *xs, 4951 struct ocfs2_xattr_set_ctxt *ctxt) 4952 { 4953 int ret, local = 1; 4954 size_t value_len; 4955 char *val = (char *)xi->value; 4956 struct ocfs2_xattr_entry *xe = xs->here; 4957 u32 name_hash = ocfs2_xattr_name_hash(inode, xi->name, 4958 strlen(xi->name)); 4959 4960 if (!xs->not_found && !ocfs2_xattr_is_local(xe)) { 4961 /* 4962 * We need to truncate the xattr storage first. 4963 * 4964 * If both the old and new value are stored to 4965 * outside block, we only need to truncate 4966 * the storage and then set the value outside. 4967 * 4968 * If the new value should be stored within block, 4969 * we should free all the outside block first and 4970 * the modification to the xattr block will be done 4971 * by following steps. 4972 */ 4973 if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) 4974 value_len = xi->value_len; 4975 else 4976 value_len = 0; 4977 4978 ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs, 4979 value_len, 4980 ctxt); 4981 if (ret) 4982 goto out; 4983 4984 if (value_len) 4985 goto set_value_outside; 4986 } 4987 4988 value_len = xi->value_len; 4989 /* So we have to handle the inside block change now. */ 4990 if (value_len > OCFS2_XATTR_INLINE_SIZE) { 4991 /* 4992 * If the new value will be stored outside of block, 4993 * initalize a new empty value root and insert it first. 4994 */ 4995 local = 0; 4996 xi->value = &def_xv; 4997 xi->value_len = OCFS2_XATTR_ROOT_SIZE; 4998 } 4999 5000 ret = ocfs2_xattr_set_entry_in_bucket(inode, ctxt->handle, xi, xs, 5001 name_hash, local); 5002 if (ret) { 5003 mlog_errno(ret); 5004 goto out; 5005 } 5006 5007 if (value_len <= OCFS2_XATTR_INLINE_SIZE) 5008 goto out; 5009 5010 /* allocate the space now for the outside block storage. */ 5011 ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs, 5012 value_len, ctxt); 5013 if (ret) { 5014 mlog_errno(ret); 5015 5016 if (xs->not_found) { 5017 /* 5018 * We can't allocate enough clusters for outside 5019 * storage and we have allocated xattr already, 5020 * so need to remove it. 5021 */ 5022 ocfs2_xattr_bucket_remove_xs(inode, ctxt->handle, xs); 5023 } 5024 goto out; 5025 } 5026 5027 set_value_outside: 5028 ret = ocfs2_xattr_bucket_set_value_outside(inode, ctxt->handle, 5029 xs, val, value_len); 5030 out: 5031 return ret; 5032 } 5033 5034 /* 5035 * check whether the xattr bucket is filled up with the same hash value. 5036 * If we want to insert the xattr with the same hash, return -ENOSPC. 5037 * If we want to insert a xattr with different hash value, go ahead 5038 * and ocfs2_divide_xattr_bucket will handle this. 5039 */ 5040 static int ocfs2_check_xattr_bucket_collision(struct inode *inode, 5041 struct ocfs2_xattr_bucket *bucket, 5042 const char *name) 5043 { 5044 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5045 u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name)); 5046 5047 if (name_hash != le32_to_cpu(xh->xh_entries[0].xe_name_hash)) 5048 return 0; 5049 5050 if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash == 5051 xh->xh_entries[0].xe_name_hash) { 5052 mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, " 5053 "hash = %u\n", 5054 (unsigned long long)bucket_blkno(bucket), 5055 le32_to_cpu(xh->xh_entries[0].xe_name_hash)); 5056 return -ENOSPC; 5057 } 5058 5059 return 0; 5060 } 5061 5062 static int ocfs2_xattr_set_entry_index_block(struct inode *inode, 5063 struct ocfs2_xattr_info *xi, 5064 struct ocfs2_xattr_search *xs, 5065 struct ocfs2_xattr_set_ctxt *ctxt) 5066 { 5067 struct ocfs2_xattr_header *xh; 5068 struct ocfs2_xattr_entry *xe; 5069 u16 count, header_size, xh_free_start; 5070 int free, max_free, need, old; 5071 size_t value_size = 0, name_len = strlen(xi->name); 5072 size_t blocksize = inode->i_sb->s_blocksize; 5073 int ret, allocation = 0; 5074 5075 mlog_entry("Set xattr %s in xattr index block\n", xi->name); 5076 5077 try_again: 5078 xh = xs->header; 5079 count = le16_to_cpu(xh->xh_count); 5080 xh_free_start = le16_to_cpu(xh->xh_free_start); 5081 header_size = sizeof(struct ocfs2_xattr_header) + 5082 count * sizeof(struct ocfs2_xattr_entry); 5083 max_free = OCFS2_XATTR_BUCKET_SIZE - header_size - 5084 le16_to_cpu(xh->xh_name_value_len) - OCFS2_XATTR_HEADER_GAP; 5085 5086 mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size " 5087 "of %u which exceed block size\n", 5088 (unsigned long long)bucket_blkno(xs->bucket), 5089 header_size); 5090 5091 if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) 5092 value_size = OCFS2_XATTR_ROOT_SIZE; 5093 else if (xi->value) 5094 value_size = OCFS2_XATTR_SIZE(xi->value_len); 5095 5096 if (xs->not_found) 5097 need = sizeof(struct ocfs2_xattr_entry) + 5098 OCFS2_XATTR_SIZE(name_len) + value_size; 5099 else { 5100 need = value_size + OCFS2_XATTR_SIZE(name_len); 5101 5102 /* 5103 * We only replace the old value if the new length is smaller 5104 * than the old one. Otherwise we will allocate new space in the 5105 * bucket to store it. 5106 */ 5107 xe = xs->here; 5108 if (ocfs2_xattr_is_local(xe)) 5109 old = OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size)); 5110 else 5111 old = OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE); 5112 5113 if (old >= value_size) 5114 need = 0; 5115 } 5116 5117 free = xh_free_start - header_size - OCFS2_XATTR_HEADER_GAP; 5118 /* 5119 * We need to make sure the new name/value pair 5120 * can exist in the same block. 5121 */ 5122 if (xh_free_start % blocksize < need) 5123 free -= xh_free_start % blocksize; 5124 5125 mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, " 5126 "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len =" 5127 " %u\n", xs->not_found, 5128 (unsigned long long)bucket_blkno(xs->bucket), 5129 free, need, max_free, le16_to_cpu(xh->xh_free_start), 5130 le16_to_cpu(xh->xh_name_value_len)); 5131 5132 if (free < need || 5133 (xs->not_found && 5134 count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb))) { 5135 if (need <= max_free && 5136 count < ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) { 5137 /* 5138 * We can create the space by defragment. Since only the 5139 * name/value will be moved, the xe shouldn't be changed 5140 * in xs. 5141 */ 5142 ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle, 5143 xs->bucket); 5144 if (ret) { 5145 mlog_errno(ret); 5146 goto out; 5147 } 5148 5149 xh_free_start = le16_to_cpu(xh->xh_free_start); 5150 free = xh_free_start - header_size 5151 - OCFS2_XATTR_HEADER_GAP; 5152 if (xh_free_start % blocksize < need) 5153 free -= xh_free_start % blocksize; 5154 5155 if (free >= need) 5156 goto xattr_set; 5157 5158 mlog(0, "Can't get enough space for xattr insert by " 5159 "defragment. Need %u bytes, but we have %d, so " 5160 "allocate new bucket for it.\n", need, free); 5161 } 5162 5163 /* 5164 * We have to add new buckets or clusters and one 5165 * allocation should leave us enough space for insert. 5166 */ 5167 BUG_ON(allocation); 5168 5169 /* 5170 * We do not allow for overlapping ranges between buckets. And 5171 * the maximum number of collisions we will allow for then is 5172 * one bucket's worth, so check it here whether we need to 5173 * add a new bucket for the insert. 5174 */ 5175 ret = ocfs2_check_xattr_bucket_collision(inode, 5176 xs->bucket, 5177 xi->name); 5178 if (ret) { 5179 mlog_errno(ret); 5180 goto out; 5181 } 5182 5183 ret = ocfs2_add_new_xattr_bucket(inode, 5184 xs->xattr_bh, 5185 xs->bucket, 5186 ctxt); 5187 if (ret) { 5188 mlog_errno(ret); 5189 goto out; 5190 } 5191 5192 /* 5193 * ocfs2_add_new_xattr_bucket() will have updated 5194 * xs->bucket if it moved, but it will not have updated 5195 * any of the other search fields. Thus, we drop it and 5196 * re-search. Everything should be cached, so it'll be 5197 * quick. 5198 */ 5199 ocfs2_xattr_bucket_relse(xs->bucket); 5200 ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh, 5201 xi->name_index, 5202 xi->name, xs); 5203 if (ret && ret != -ENODATA) 5204 goto out; 5205 xs->not_found = ret; 5206 allocation = 1; 5207 goto try_again; 5208 } 5209 5210 xattr_set: 5211 ret = ocfs2_xattr_set_in_bucket(inode, xi, xs, ctxt); 5212 out: 5213 mlog_exit(ret); 5214 return ret; 5215 } 5216 5217 static int ocfs2_delete_xattr_in_bucket(struct inode *inode, 5218 struct ocfs2_xattr_bucket *bucket, 5219 void *para) 5220 { 5221 int ret = 0; 5222 struct ocfs2_xattr_header *xh = bucket_xh(bucket); 5223 u16 i; 5224 struct ocfs2_xattr_entry *xe; 5225 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5226 struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,}; 5227 int credits = ocfs2_remove_extent_credits(osb->sb) + 5228 ocfs2_blocks_per_xattr_bucket(inode->i_sb); 5229 5230 5231 ocfs2_init_dealloc_ctxt(&ctxt.dealloc); 5232 5233 for (i = 0; i < le16_to_cpu(xh->xh_count); i++) { 5234 xe = &xh->xh_entries[i]; 5235 if (ocfs2_xattr_is_local(xe)) 5236 continue; 5237 5238 ctxt.handle = ocfs2_start_trans(osb, credits); 5239 if (IS_ERR(ctxt.handle)) { 5240 ret = PTR_ERR(ctxt.handle); 5241 mlog_errno(ret); 5242 break; 5243 } 5244 5245 ret = ocfs2_xattr_bucket_value_truncate(inode, bucket, 5246 i, 0, &ctxt); 5247 5248 ocfs2_commit_trans(osb, ctxt.handle); 5249 if (ret) { 5250 mlog_errno(ret); 5251 break; 5252 } 5253 } 5254 5255 ocfs2_schedule_truncate_log_flush(osb, 1); 5256 ocfs2_run_deallocs(osb, &ctxt.dealloc); 5257 return ret; 5258 } 5259 5260 static int ocfs2_delete_xattr_index_block(struct inode *inode, 5261 struct buffer_head *xb_bh) 5262 { 5263 struct ocfs2_xattr_block *xb = 5264 (struct ocfs2_xattr_block *)xb_bh->b_data; 5265 struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list; 5266 int ret = 0; 5267 u32 name_hash = UINT_MAX, e_cpos, num_clusters; 5268 u64 p_blkno; 5269 5270 if (le16_to_cpu(el->l_next_free_rec) == 0) 5271 return 0; 5272 5273 while (name_hash > 0) { 5274 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, 5275 &e_cpos, &num_clusters, el); 5276 if (ret) { 5277 mlog_errno(ret); 5278 goto out; 5279 } 5280 5281 ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters, 5282 ocfs2_delete_xattr_in_bucket, 5283 NULL); 5284 if (ret) { 5285 mlog_errno(ret); 5286 goto out; 5287 } 5288 5289 ret = ocfs2_rm_xattr_cluster(inode, xb_bh, 5290 p_blkno, e_cpos, num_clusters); 5291 if (ret) { 5292 mlog_errno(ret); 5293 break; 5294 } 5295 5296 if (e_cpos == 0) 5297 break; 5298 5299 name_hash = e_cpos - 1; 5300 } 5301 5302 out: 5303 return ret; 5304 } 5305 5306 /* 5307 * 'security' attributes support 5308 */ 5309 static size_t ocfs2_xattr_security_list(struct inode *inode, char *list, 5310 size_t list_size, const char *name, 5311 size_t name_len) 5312 { 5313 const size_t prefix_len = XATTR_SECURITY_PREFIX_LEN; 5314 const size_t total_len = prefix_len + name_len + 1; 5315 5316 if (list && total_len <= list_size) { 5317 memcpy(list, XATTR_SECURITY_PREFIX, prefix_len); 5318 memcpy(list + prefix_len, name, name_len); 5319 list[prefix_len + name_len] = '\0'; 5320 } 5321 return total_len; 5322 } 5323 5324 static int ocfs2_xattr_security_get(struct inode *inode, const char *name, 5325 void *buffer, size_t size) 5326 { 5327 if (strcmp(name, "") == 0) 5328 return -EINVAL; 5329 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_SECURITY, name, 5330 buffer, size); 5331 } 5332 5333 static int ocfs2_xattr_security_set(struct inode *inode, const char *name, 5334 const void *value, size_t size, int flags) 5335 { 5336 if (strcmp(name, "") == 0) 5337 return -EINVAL; 5338 5339 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY, name, value, 5340 size, flags); 5341 } 5342 5343 int ocfs2_init_security_get(struct inode *inode, 5344 struct inode *dir, 5345 struct ocfs2_security_xattr_info *si) 5346 { 5347 /* check whether ocfs2 support feature xattr */ 5348 if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb))) 5349 return -EOPNOTSUPP; 5350 return security_inode_init_security(inode, dir, &si->name, &si->value, 5351 &si->value_len); 5352 } 5353 5354 int ocfs2_init_security_set(handle_t *handle, 5355 struct inode *inode, 5356 struct buffer_head *di_bh, 5357 struct ocfs2_security_xattr_info *si, 5358 struct ocfs2_alloc_context *xattr_ac, 5359 struct ocfs2_alloc_context *data_ac) 5360 { 5361 return ocfs2_xattr_set_handle(handle, inode, di_bh, 5362 OCFS2_XATTR_INDEX_SECURITY, 5363 si->name, si->value, si->value_len, 0, 5364 xattr_ac, data_ac); 5365 } 5366 5367 struct xattr_handler ocfs2_xattr_security_handler = { 5368 .prefix = XATTR_SECURITY_PREFIX, 5369 .list = ocfs2_xattr_security_list, 5370 .get = ocfs2_xattr_security_get, 5371 .set = ocfs2_xattr_security_set, 5372 }; 5373 5374 /* 5375 * 'trusted' attributes support 5376 */ 5377 static size_t ocfs2_xattr_trusted_list(struct inode *inode, char *list, 5378 size_t list_size, const char *name, 5379 size_t name_len) 5380 { 5381 const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN; 5382 const size_t total_len = prefix_len + name_len + 1; 5383 5384 if (list && total_len <= list_size) { 5385 memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len); 5386 memcpy(list + prefix_len, name, name_len); 5387 list[prefix_len + name_len] = '\0'; 5388 } 5389 return total_len; 5390 } 5391 5392 static int ocfs2_xattr_trusted_get(struct inode *inode, const char *name, 5393 void *buffer, size_t size) 5394 { 5395 if (strcmp(name, "") == 0) 5396 return -EINVAL; 5397 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED, name, 5398 buffer, size); 5399 } 5400 5401 static int ocfs2_xattr_trusted_set(struct inode *inode, const char *name, 5402 const void *value, size_t size, int flags) 5403 { 5404 if (strcmp(name, "") == 0) 5405 return -EINVAL; 5406 5407 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_TRUSTED, name, value, 5408 size, flags); 5409 } 5410 5411 struct xattr_handler ocfs2_xattr_trusted_handler = { 5412 .prefix = XATTR_TRUSTED_PREFIX, 5413 .list = ocfs2_xattr_trusted_list, 5414 .get = ocfs2_xattr_trusted_get, 5415 .set = ocfs2_xattr_trusted_set, 5416 }; 5417 5418 /* 5419 * 'user' attributes support 5420 */ 5421 static size_t ocfs2_xattr_user_list(struct inode *inode, char *list, 5422 size_t list_size, const char *name, 5423 size_t name_len) 5424 { 5425 const size_t prefix_len = XATTR_USER_PREFIX_LEN; 5426 const size_t total_len = prefix_len + name_len + 1; 5427 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5428 5429 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 5430 return 0; 5431 5432 if (list && total_len <= list_size) { 5433 memcpy(list, XATTR_USER_PREFIX, prefix_len); 5434 memcpy(list + prefix_len, name, name_len); 5435 list[prefix_len + name_len] = '\0'; 5436 } 5437 return total_len; 5438 } 5439 5440 static int ocfs2_xattr_user_get(struct inode *inode, const char *name, 5441 void *buffer, size_t size) 5442 { 5443 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5444 5445 if (strcmp(name, "") == 0) 5446 return -EINVAL; 5447 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 5448 return -EOPNOTSUPP; 5449 return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name, 5450 buffer, size); 5451 } 5452 5453 static int ocfs2_xattr_user_set(struct inode *inode, const char *name, 5454 const void *value, size_t size, int flags) 5455 { 5456 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 5457 5458 if (strcmp(name, "") == 0) 5459 return -EINVAL; 5460 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 5461 return -EOPNOTSUPP; 5462 5463 return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_USER, name, value, 5464 size, flags); 5465 } 5466 5467 struct xattr_handler ocfs2_xattr_user_handler = { 5468 .prefix = XATTR_USER_PREFIX, 5469 .list = ocfs2_xattr_user_list, 5470 .get = ocfs2_xattr_user_get, 5471 .set = ocfs2_xattr_user_set, 5472 }; 5473