fs/ocfs2/xattr.c

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