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) 2008 Oracle.  All rights reserved.
   7  *
   8  * CREDITS:
   9  * Lots of code in this file is taken from ext3.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  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  * You should have received a copy of the GNU General Public
  22  * License along with this program; if not, write to the
  23  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24  * Boston, MA 021110-1307, USA.
  25  */
  26
  27 #include <linux/capability.h>
  28 #include <linux/fs.h>
  29 #include <linux/types.h>
  30 #include <linux/slab.h>
  31 #include <linux/highmem.h>
  32 #include <linux/pagemap.h>
  33 #include <linux/uio.h>
  34 #include <linux/sched.h>
  35 #include <linux/splice.h>
  36 #include <linux/mount.h>
  37 #include <linux/writeback.h>
  38 #include <linux/falloc.h>
  39
  40 #define MLOG_MASK_PREFIX ML_XATTR
  41 #include <cluster/masklog.h>
  42
  43 #include "ocfs2.h"
  44 #include "alloc.h"
  45 #include "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
  58
  59 struct ocfs2_xattr_def_value_root {
  60         struct ocfs2_xattr_value_root   xv;
  61         struct ocfs2_extent_rec         er;
  62 };
  63
  64 struct ocfs2_xattr_bucket {
  65         struct buffer_head *bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
  66         struct ocfs2_xattr_header *xh;
  67 };
  68
  69 #define OCFS2_XATTR_ROOT_SIZE   (sizeof(struct ocfs2_xattr_def_value_root))
  70 #define OCFS2_XATTR_INLINE_SIZE 80
  71
  72 static struct ocfs2_xattr_def_value_root def_xv = {
  73         .xv.xr_list.l_count = cpu_to_le16(1),
  74 };
  75
  76 struct xattr_handler *ocfs2_xattr_handlers[] = {
  77         &ocfs2_xattr_user_handler,
  78         &ocfs2_xattr_trusted_handler,
  79         NULL
  80 };
  81
  82 static struct xattr_handler *ocfs2_xattr_handler_map[] = {
  83         [OCFS2_XATTR_INDEX_USER]        = &ocfs2_xattr_user_handler,
  84         [OCFS2_XATTR_INDEX_TRUSTED]     = &ocfs2_xattr_trusted_handler,
  85 };
  86
  87 struct ocfs2_xattr_info {
  88         int name_index;
  89         const char *name;
  90         const void *value;
  91         size_t value_len;
  92 };
  93
  94 struct ocfs2_xattr_search {
  95         struct buffer_head *inode_bh;
  96         /*
  97          * xattr_bh point to the block buffer head which has extended attribute
  98          * when extended attribute in inode, xattr_bh is equal to inode_bh.
  99          */
 100         struct buffer_head *xattr_bh;
 101         struct ocfs2_xattr_header *header;
 102         struct ocfs2_xattr_bucket bucket;
 103         void *base;
 104         void *end;
 105         struct ocfs2_xattr_entry *here;
 106         int not_found;
 107 };
 108
 109 static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
 110                                              struct ocfs2_xattr_header *xh,
 111                                              int index,
 112                                              int *block_off,
 113                                              int *new_offset);
 114
 115 static int ocfs2_xattr_index_block_find(struct inode *inode,
 116                                         struct buffer_head *root_bh,
 117                                         int name_index,
 118                                         const char *name,
 119                                         struct ocfs2_xattr_search *xs);
 120
 121 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
 122                                         struct ocfs2_xattr_tree_root *xt,
 123                                         char *buffer,
 124                                         size_t buffer_size);
 125
 126 static inline struct xattr_handler *ocfs2_xattr_handler(int name_index)
 127 {
 128         struct xattr_handler *handler = NULL;
 129
 130         if (name_index > 0 && name_index < OCFS2_XATTR_MAX)
 131                 handler = ocfs2_xattr_handler_map[name_index];
 132
 133         return handler;
 134 }
 135
 136 static inline u32 ocfs2_xattr_name_hash(struct inode *inode,
 137                                         char *prefix,
 138                                         int prefix_len,
 139                                         char *name,
 140                                         int name_len)
 141 {
 142         /* Get hash value of uuid from super block */
 143         u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash;
 144         int i;
 145
 146         /* hash extended attribute prefix */
 147         for (i = 0; i < prefix_len; i++) {
 148                 hash = (hash << OCFS2_HASH_SHIFT) ^
 149                        (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
 150                        *prefix++;
 151         }
 152         /* hash extended attribute name */
 153         for (i = 0; i < name_len; i++) {
 154                 hash = (hash << OCFS2_HASH_SHIFT) ^
 155                        (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
 156                        *name++;
 157         }
 158
 159         return hash;
 160 }
 161
 162 /*
 163  * ocfs2_xattr_hash_entry()
 164  *
 165  * Compute the hash of an extended attribute.
 166  */
 167 static void ocfs2_xattr_hash_entry(struct inode *inode,
 168                                    struct ocfs2_xattr_header *header,
 169                                    struct ocfs2_xattr_entry *entry)
 170 {
 171         u32 hash = 0;
 172         struct xattr_handler *handler =
 173                         ocfs2_xattr_handler(ocfs2_xattr_get_type(entry));
 174         char *prefix = handler->prefix;
 175         char *name = (char *)header + le16_to_cpu(entry->xe_name_offset);
 176         int prefix_len = strlen(handler->prefix);
 177
 178         hash = ocfs2_xattr_name_hash(inode, prefix, prefix_len, name,
 179                                      entry->xe_name_len);
 180         entry->xe_name_hash = cpu_to_le32(hash);
 181
 182         return;
 183 }
 184
 185 static int ocfs2_xattr_extend_allocation(struct inode *inode,
 186                                          u32 clusters_to_add,
 187                                          struct buffer_head *xattr_bh,
 188                                          struct ocfs2_xattr_value_root *xv)
 189 {
 190         int status = 0;
 191         int restart_func = 0;
 192         int credits = 0;
 193         handle_t *handle = NULL;
 194         struct ocfs2_alloc_context *data_ac = NULL;
 195         struct ocfs2_alloc_context *meta_ac = NULL;
 196         enum ocfs2_alloc_restarted why;
 197         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 198         struct ocfs2_extent_list *root_el = &xv->xr_list;
 199         u32 prev_clusters, logical_start = le32_to_cpu(xv->xr_clusters);
 200
 201         mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add);
 202
 203 restart_all:
 204
 205         status = ocfs2_lock_allocators(inode, xattr_bh, root_el,
 206                                        clusters_to_add, 0, &data_ac,
 207                                        &meta_ac, OCFS2_XATTR_VALUE_EXTENT, xv);
 208         if (status) {
 209                 mlog_errno(status);
 210                 goto leave;
 211         }
 212
 213         credits = ocfs2_calc_extend_credits(osb->sb, root_el, clusters_to_add);
 214         handle = ocfs2_start_trans(osb, credits);
 215         if (IS_ERR(handle)) {
 216                 status = PTR_ERR(handle);
 217                 handle = NULL;
 218                 mlog_errno(status);
 219                 goto leave;
 220         }
 221
 222 restarted_transaction:
 223         status = ocfs2_journal_access(handle, inode, xattr_bh,
 224                                       OCFS2_JOURNAL_ACCESS_WRITE);
 225         if (status < 0) {
 226                 mlog_errno(status);
 227                 goto leave;
 228         }
 229
 230         prev_clusters = le32_to_cpu(xv->xr_clusters);
 231         status = ocfs2_add_clusters_in_btree(osb,
 232                                              inode,
 233                                              &logical_start,
 234                                              clusters_to_add,
 235                                              0,
 236                                              xattr_bh,
 237                                              root_el,
 238                                              handle,
 239                                              data_ac,
 240                                              meta_ac,
 241                                              &why,
 242                                              OCFS2_XATTR_VALUE_EXTENT,
 243                                              xv);
 244         if ((status < 0) && (status != -EAGAIN)) {
 245                 if (status != -ENOSPC)
 246                         mlog_errno(status);
 247                 goto leave;
 248         }
 249
 250         status = ocfs2_journal_dirty(handle, xattr_bh);
 251         if (status < 0) {
 252                 mlog_errno(status);
 253                 goto leave;
 254         }
 255
 256         clusters_to_add -= le32_to_cpu(xv->xr_clusters) - prev_clusters;
 257
 258         if (why != RESTART_NONE && clusters_to_add) {
 259                 if (why == RESTART_META) {
 260                         mlog(0, "restarting function.\n");
 261                         restart_func = 1;
 262                 } else {
 263                         BUG_ON(why != RESTART_TRANS);
 264
 265                         mlog(0, "restarting transaction.\n");
 266                         /* TODO: This can be more intelligent. */
 267                         credits = ocfs2_calc_extend_credits(osb->sb,
 268                                                             root_el,
 269                                                             clusters_to_add);
 270                         status = ocfs2_extend_trans(handle, credits);
 271                         if (status < 0) {
 272                                 /* handle still has to be committed at
 273                                  * this point. */
 274                                 status = -ENOMEM;
 275                                 mlog_errno(status);
 276                                 goto leave;
 277                         }
 278                         goto restarted_transaction;
 279                 }
 280         }
 281
 282 leave:
 283         if (handle) {
 284                 ocfs2_commit_trans(osb, handle);
 285                 handle = NULL;
 286         }
 287         if (data_ac) {
 288                 ocfs2_free_alloc_context(data_ac);
 289                 data_ac = NULL;
 290         }
 291         if (meta_ac) {
 292                 ocfs2_free_alloc_context(meta_ac);
 293                 meta_ac = NULL;
 294         }
 295         if ((!status) && restart_func) {
 296                 restart_func = 0;
 297                 goto restart_all;
 298         }
 299
 300         return status;
 301 }
 302
 303 static int __ocfs2_remove_xattr_range(struct inode *inode,
 304                                       struct buffer_head *root_bh,
 305                                       struct ocfs2_xattr_value_root *xv,
 306                                       u32 cpos, u32 phys_cpos, u32 len,
 307                                       struct ocfs2_cached_dealloc_ctxt *dealloc)
 308 {
 309         int ret;
 310         u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
 311         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 312         struct inode *tl_inode = osb->osb_tl_inode;
 313         handle_t *handle;
 314         struct ocfs2_alloc_context *meta_ac = NULL;
 315
 316         ret = ocfs2_lock_allocators(inode, root_bh, &xv->xr_list,
 317                                     0, 1, NULL, &meta_ac,
 318                                     OCFS2_XATTR_VALUE_EXTENT, xv);
 319         if (ret) {
 320                 mlog_errno(ret);
 321                 return ret;
 322         }
 323
 324         mutex_lock(&tl_inode->i_mutex);
 325
 326         if (ocfs2_truncate_log_needs_flush(osb)) {
 327                 ret = __ocfs2_flush_truncate_log(osb);
 328                 if (ret < 0) {
 329                         mlog_errno(ret);
 330                         goto out;
 331                 }
 332         }
 333
 334         handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
 335         if (IS_ERR(handle)) {
 336                 ret = PTR_ERR(handle);
 337                 mlog_errno(ret);
 338                 goto out;
 339         }
 340
 341         ret = ocfs2_journal_access(handle, inode, root_bh,
 342                                    OCFS2_JOURNAL_ACCESS_WRITE);
 343         if (ret) {
 344                 mlog_errno(ret);
 345                 goto out_commit;
 346         }
 347
 348         ret = ocfs2_remove_extent(inode, root_bh, cpos, len, handle, meta_ac,
 349                                   dealloc, OCFS2_XATTR_VALUE_EXTENT, xv);
 350         if (ret) {
 351                 mlog_errno(ret);
 352                 goto out_commit;
 353         }
 354
 355         le32_add_cpu(&xv->xr_clusters, -len);
 356
 357         ret = ocfs2_journal_dirty(handle, root_bh);
 358         if (ret) {
 359                 mlog_errno(ret);
 360                 goto out_commit;
 361         }
 362
 363         ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len);
 364         if (ret)
 365                 mlog_errno(ret);
 366
 367 out_commit:
 368         ocfs2_commit_trans(osb, handle);
 369 out:
 370         mutex_unlock(&tl_inode->i_mutex);
 371
 372         if (meta_ac)
 373                 ocfs2_free_alloc_context(meta_ac);
 374
 375         return ret;
 376 }
 377
 378 static int ocfs2_xattr_shrink_size(struct inode *inode,
 379                                    u32 old_clusters,
 380                                    u32 new_clusters,
 381                                    struct buffer_head *root_bh,
 382                                    struct ocfs2_xattr_value_root *xv)
 383 {
 384         int ret = 0;
 385         u32 trunc_len, cpos, phys_cpos, alloc_size;
 386         u64 block;
 387         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 388         struct ocfs2_cached_dealloc_ctxt dealloc;
 389
 390         ocfs2_init_dealloc_ctxt(&dealloc);
 391
 392         if (old_clusters <= new_clusters)
 393                 return 0;
 394
 395         cpos = new_clusters;
 396         trunc_len = old_clusters - new_clusters;
 397         while (trunc_len) {
 398                 ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
 399                                                &alloc_size, &xv->xr_list);
 400                 if (ret) {
 401                         mlog_errno(ret);
 402                         goto out;
 403                 }
 404
 405                 if (alloc_size > trunc_len)
 406                         alloc_size = trunc_len;
 407
 408                 ret = __ocfs2_remove_xattr_range(inode, root_bh, xv, cpos,
 409                                                  phys_cpos, alloc_size,
 410                                                  &dealloc);
 411                 if (ret) {
 412                         mlog_errno(ret);
 413                         goto out;
 414                 }
 415
 416                 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
 417                 ocfs2_remove_xattr_clusters_from_cache(inode, block,
 418                                                        alloc_size);
 419                 cpos += alloc_size;
 420                 trunc_len -= alloc_size;
 421         }
 422
 423 out:
 424         ocfs2_schedule_truncate_log_flush(osb, 1);
 425         ocfs2_run_deallocs(osb, &dealloc);
 426
 427         return ret;
 428 }
 429
 430 static int ocfs2_xattr_value_truncate(struct inode *inode,
 431                                       struct buffer_head *root_bh,
 432                                       struct ocfs2_xattr_value_root *xv,
 433                                       int len)
 434 {
 435         int ret;
 436         u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
 437         u32 old_clusters = le32_to_cpu(xv->xr_clusters);
 438
 439         if (new_clusters == old_clusters)
 440                 return 0;
 441
 442         if (new_clusters > old_clusters)
 443                 ret = ocfs2_xattr_extend_allocation(inode,
 444                                                     new_clusters - old_clusters,
 445                                                     root_bh, xv);
 446         else
 447                 ret = ocfs2_xattr_shrink_size(inode,
 448                                               old_clusters, new_clusters,
 449                                               root_bh, xv);
 450
 451         return ret;
 452 }
 453
 454 static int ocfs2_xattr_list_entries(struct inode *inode,
 455                                     struct ocfs2_xattr_header *header,
 456                                     char *buffer, size_t buffer_size)
 457 {
 458         size_t rest = buffer_size;
 459         int i;
 460
 461         for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) {
 462                 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
 463                 struct xattr_handler *handler =
 464                         ocfs2_xattr_handler(ocfs2_xattr_get_type(entry));
 465
 466                 if (handler) {
 467                         size_t size = handler->list(inode, buffer, rest,
 468                                         ((char *)header +
 469                                         le16_to_cpu(entry->xe_name_offset)),
 470                                         entry->xe_name_len);
 471                         if (buffer) {
 472                                 if (size > rest)
 473                                         return -ERANGE;
 474                                 buffer += size;
 475                         }
 476                         rest -= size;
 477                 }
 478         }
 479
 480         return buffer_size - rest;
 481 }
 482
 483 static int ocfs2_xattr_ibody_list(struct inode *inode,
 484                                   struct ocfs2_dinode *di,
 485                                   char *buffer,
 486                                   size_t buffer_size)
 487 {
 488         struct ocfs2_xattr_header *header = NULL;
 489         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 490         int ret = 0;
 491
 492         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
 493                 return ret;
 494
 495         header = (struct ocfs2_xattr_header *)
 496                  ((void *)di + inode->i_sb->s_blocksize -
 497                  le16_to_cpu(di->i_xattr_inline_size));
 498
 499         ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
 500
 501         return ret;
 502 }
 503
 504 static int ocfs2_xattr_block_list(struct inode *inode,
 505                                   struct ocfs2_dinode *di,
 506                                   char *buffer,
 507                                   size_t buffer_size)
 508 {
 509         struct buffer_head *blk_bh = NULL;
 510         struct ocfs2_xattr_block *xb;
 511         int ret = 0;
 512
 513         if (!di->i_xattr_loc)
 514                 return ret;
 515
 516         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
 517                                le64_to_cpu(di->i_xattr_loc),
 518                                &blk_bh, OCFS2_BH_CACHED, inode);
 519         if (ret < 0) {
 520                 mlog_errno(ret);
 521                 return ret;
 522         }
 523         /*Verify the signature of xattr block*/
 524         if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
 525                    strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
 526                 ret = -EFAULT;
 527                 goto cleanup;
 528         }
 529
 530         xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
 531
 532         if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
 533                 struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
 534                 ret = ocfs2_xattr_list_entries(inode, header,
 535                                                buffer, buffer_size);
 536         } else {
 537                 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
 538                 ret = ocfs2_xattr_tree_list_index_block(inode, xt,
 539                                                    buffer, buffer_size);
 540         }
 541 cleanup:
 542         brelse(blk_bh);
 543
 544         return ret;
 545 }
 546
 547 ssize_t ocfs2_listxattr(struct dentry *dentry,
 548                         char *buffer,
 549                         size_t size)
 550 {
 551         int ret = 0, i_ret = 0, b_ret = 0;
 552         struct buffer_head *di_bh = NULL;
 553         struct ocfs2_dinode *di = NULL;
 554         struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode);
 555
 556         if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
 557                 return ret;
 558
 559         ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0);
 560         if (ret < 0) {
 561                 mlog_errno(ret);
 562                 return ret;
 563         }
 564
 565         di = (struct ocfs2_dinode *)di_bh->b_data;
 566
 567         down_read(&oi->ip_xattr_sem);
 568         i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size);
 569         if (i_ret < 0)
 570                 b_ret = 0;
 571         else {
 572                 if (buffer) {
 573                         buffer += i_ret;
 574                         size -= i_ret;
 575                 }
 576                 b_ret = ocfs2_xattr_block_list(dentry->d_inode, di,
 577                                                buffer, size);
 578                 if (b_ret < 0)
 579                         i_ret = 0;
 580         }
 581         up_read(&oi->ip_xattr_sem);
 582         ocfs2_inode_unlock(dentry->d_inode, 0);
 583
 584         brelse(di_bh);
 585
 586         return i_ret + b_ret;
 587 }
 588
 589 static int ocfs2_xattr_find_entry(int name_index,
 590                                   const char *name,
 591                                   struct ocfs2_xattr_search *xs)
 592 {
 593         struct ocfs2_xattr_entry *entry;
 594         size_t name_len;
 595         int i, cmp = 1;
 596
 597         if (name == NULL)
 598                 return -EINVAL;
 599
 600         name_len = strlen(name);
 601         entry = xs->here;
 602         for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
 603                 cmp = name_index - ocfs2_xattr_get_type(entry);
 604                 if (!cmp)
 605                         cmp = name_len - entry->xe_name_len;
 606                 if (!cmp)
 607                         cmp = memcmp(name, (xs->base +
 608                                      le16_to_cpu(entry->xe_name_offset)),
 609                                      name_len);
 610                 if (cmp == 0)
 611                         break;
 612                 entry += 1;
 613         }
 614         xs->here = entry;
 615
 616         return cmp ? -ENODATA : 0;
 617 }
 618
 619 static int ocfs2_xattr_get_value_outside(struct inode *inode,
 620                                          struct ocfs2_xattr_value_root *xv,
 621                                          void *buffer,
 622                                          size_t len)
 623 {
 624         u32 cpos, p_cluster, num_clusters, bpc, clusters;
 625         u64 blkno;
 626         int i, ret = 0;
 627         size_t cplen, blocksize;
 628         struct buffer_head *bh = NULL;
 629         struct ocfs2_extent_list *el;
 630
 631         el = &xv->xr_list;
 632         clusters = le32_to_cpu(xv->xr_clusters);
 633         bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
 634         blocksize = inode->i_sb->s_blocksize;
 635
 636         cpos = 0;
 637         while (cpos < clusters) {
 638                 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
 639                                                &num_clusters, el);
 640                 if (ret) {
 641                         mlog_errno(ret);
 642                         goto out;
 643                 }
 644
 645                 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
 646                 /* Copy ocfs2_xattr_value */
 647                 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
 648                         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
 649                                                &bh, OCFS2_BH_CACHED, inode);
 650                         if (ret) {
 651                                 mlog_errno(ret);
 652                                 goto out;
 653                         }
 654
 655                         cplen = len >= blocksize ? blocksize : len;
 656                         memcpy(buffer, bh->b_data, cplen);
 657                         len -= cplen;
 658                         buffer += cplen;
 659
 660                         brelse(bh);
 661                         bh = NULL;
 662                         if (len == 0)
 663                                 break;
 664                 }
 665                 cpos += num_clusters;
 666         }
 667 out:
 668         return ret;
 669 }
 670
 671 static int ocfs2_xattr_ibody_get(struct inode *inode,
 672                                  int name_index,
 673                                  const char *name,
 674                                  void *buffer,
 675                                  size_t buffer_size,
 676                                  struct ocfs2_xattr_search *xs)
 677 {
 678         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 679         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
 680         struct ocfs2_xattr_value_root *xv;
 681         size_t size;
 682         int ret = 0;
 683
 684         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
 685                 return -ENODATA;
 686
 687         xs->end = (void *)di + inode->i_sb->s_blocksize;
 688         xs->header = (struct ocfs2_xattr_header *)
 689                         (xs->end - le16_to_cpu(di->i_xattr_inline_size));
 690         xs->base = (void *)xs->header;
 691         xs->here = xs->header->xh_entries;
 692
 693         ret = ocfs2_xattr_find_entry(name_index, name, xs);
 694         if (ret)
 695                 return ret;
 696         size = le64_to_cpu(xs->here->xe_value_size);
 697         if (buffer) {
 698                 if (size > buffer_size)
 699                         return -ERANGE;
 700                 if (ocfs2_xattr_is_local(xs->here)) {
 701                         memcpy(buffer, (void *)xs->base +
 702                                le16_to_cpu(xs->here->xe_name_offset) +
 703                                OCFS2_XATTR_SIZE(xs->here->xe_name_len), size);
 704                 } else {
 705                         xv = (struct ocfs2_xattr_value_root *)
 706                                 (xs->base + le16_to_cpu(
 707                                  xs->here->xe_name_offset) +
 708                                 OCFS2_XATTR_SIZE(xs->here->xe_name_len));
 709                         ret = ocfs2_xattr_get_value_outside(inode, xv,
 710                                                             buffer, size);
 711                         if (ret < 0) {
 712                                 mlog_errno(ret);
 713                                 return ret;
 714                         }
 715                 }
 716         }
 717
 718         return size;
 719 }
 720
 721 static int ocfs2_xattr_block_get(struct inode *inode,
 722                                  int name_index,
 723                                  const char *name,
 724                                  void *buffer,
 725                                  size_t buffer_size,
 726                                  struct ocfs2_xattr_search *xs)
 727 {
 728         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
 729         struct buffer_head *blk_bh = NULL;
 730         struct ocfs2_xattr_block *xb;
 731         struct ocfs2_xattr_value_root *xv;
 732         size_t size;
 733         int ret = -ENODATA, name_offset, name_len, block_off, i;
 734
 735         if (!di->i_xattr_loc)
 736                 return ret;
 737
 738         memset(&xs->bucket, 0, sizeof(xs->bucket));
 739
 740         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
 741                                le64_to_cpu(di->i_xattr_loc),
 742                                &blk_bh, OCFS2_BH_CACHED, inode);
 743         if (ret < 0) {
 744                 mlog_errno(ret);
 745                 return ret;
 746         }
 747         /*Verify the signature of xattr block*/
 748         if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
 749                    strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
 750                 ret = -EFAULT;
 751                 goto cleanup;
 752         }
 753
 754         xs->xattr_bh = blk_bh;
 755         xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
 756
 757         if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
 758                 xs->header = &xb->xb_attrs.xb_header;
 759                 xs->base = (void *)xs->header;
 760                 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
 761                 xs->here = xs->header->xh_entries;
 762
 763                 ret = ocfs2_xattr_find_entry(name_index, name, xs);
 764         } else
 765                 ret = ocfs2_xattr_index_block_find(inode, blk_bh,
 766                                                    name_index,
 767                                                    name, xs);
 768
 769         if (ret)
 770                 goto cleanup;
 771         size = le64_to_cpu(xs->here->xe_value_size);
 772         if (buffer) {
 773                 ret = -ERANGE;
 774                 if (size > buffer_size)
 775                         goto cleanup;
 776
 777                 name_offset = le16_to_cpu(xs->here->xe_name_offset);
 778                 name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len);
 779                 i = xs->here - xs->header->xh_entries;
 780
 781                 if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
 782                         ret = ocfs2_xattr_bucket_get_name_value(inode,
 783                                                                 xs->bucket.xh,
 784                                                                 i,
 785                                                                 &block_off,
 786                                                                 &name_offset);
 787                         xs->base = xs->bucket.bhs[block_off]->b_data;
 788                 }
 789                 if (ocfs2_xattr_is_local(xs->here)) {
 790                         memcpy(buffer, (void *)xs->base +
 791                                name_offset + name_len, size);
 792                 } else {
 793                         xv = (struct ocfs2_xattr_value_root *)
 794                                 (xs->base + name_offset + name_len);
 795                         ret = ocfs2_xattr_get_value_outside(inode, xv,
 796                                                             buffer, size);
 797                         if (ret < 0) {
 798                                 mlog_errno(ret);
 799                                 goto cleanup;
 800                         }
 801                 }
 802         }
 803         ret = size;
 804 cleanup:
 805         for (i = 0; i < OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET; i++)
 806                 brelse(xs->bucket.bhs[i]);
 807         memset(&xs->bucket, 0, sizeof(xs->bucket));
 808
 809         brelse(blk_bh);
 810         return ret;
 811 }
 812
 813 /* ocfs2_xattr_get()
 814  *
 815  * Copy an extended attribute into the buffer provided.
 816  * Buffer is NULL to compute the size of buffer required.
 817  */
 818 int ocfs2_xattr_get(struct inode *inode,
 819                     int name_index,
 820                     const char *name,
 821                     void *buffer,
 822                     size_t buffer_size)
 823 {
 824         int ret;
 825         struct ocfs2_dinode *di = NULL;
 826         struct buffer_head *di_bh = NULL;
 827         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 828         struct ocfs2_xattr_search xis = {
 829                 .not_found = -ENODATA,
 830         };
 831         struct ocfs2_xattr_search xbs = {
 832                 .not_found = -ENODATA,
 833         };
 834
 835         if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
 836                 ret = -ENODATA;
 837
 838         ret = ocfs2_inode_lock(inode, &di_bh, 0);
 839         if (ret < 0) {
 840                 mlog_errno(ret);
 841                 return ret;
 842         }
 843         xis.inode_bh = xbs.inode_bh = di_bh;
 844         di = (struct ocfs2_dinode *)di_bh->b_data;
 845
 846         down_read(&oi->ip_xattr_sem);
 847         ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer,
 848                                     buffer_size, &xis);
 849         if (ret == -ENODATA)
 850                 ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
 851                                             buffer_size, &xbs);
 852         up_read(&oi->ip_xattr_sem);
 853         ocfs2_inode_unlock(inode, 0);
 854
 855         brelse(di_bh);
 856
 857         return ret;
 858 }
 859
 860 static int __ocfs2_xattr_set_value_outside(struct inode *inode,
 861                                            struct ocfs2_xattr_value_root *xv,
 862                                            const void *value,
 863                                            int value_len)
 864 {
 865         int ret = 0, i, cp_len, credits;
 866         u16 blocksize = inode->i_sb->s_blocksize;
 867         u32 p_cluster, num_clusters;
 868         u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
 869         u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
 870         u64 blkno;
 871         struct buffer_head *bh = NULL;
 872         handle_t *handle;
 873
 874         BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
 875
 876         credits = clusters * bpc;
 877         handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), credits);
 878         if (IS_ERR(handle)) {
 879                 ret = PTR_ERR(handle);
 880                 mlog_errno(ret);
 881                 goto out;
 882         }
 883
 884         while (cpos < clusters) {
 885                 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
 886                                                &num_clusters, &xv->xr_list);
 887                 if (ret) {
 888                         mlog_errno(ret);
 889                         goto out_commit;
 890                 }
 891
 892                 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
 893
 894                 for (i = 0; i < num_clusters * bpc; i++, blkno++) {
 895                         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
 896                                                &bh, OCFS2_BH_CACHED, inode);
 897                         if (ret) {
 898                                 mlog_errno(ret);
 899                                 goto out_commit;
 900                         }
 901
 902                         ret = ocfs2_journal_access(handle,
 903                                                    inode,
 904                                                    bh,
 905                                                    OCFS2_JOURNAL_ACCESS_WRITE);
 906                         if (ret < 0) {
 907                                 mlog_errno(ret);
 908                                 goto out_commit;
 909                         }
 910
 911                         cp_len = value_len > blocksize ? blocksize : value_len;
 912                         memcpy(bh->b_data, value, cp_len);
 913                         value_len -= cp_len;
 914                         value += cp_len;
 915                         if (cp_len < blocksize)
 916                                 memset(bh->b_data + cp_len, 0,
 917                                        blocksize - cp_len);
 918
 919                         ret = ocfs2_journal_dirty(handle, bh);
 920                         if (ret < 0) {
 921                                 mlog_errno(ret);
 922                                 goto out_commit;
 923                         }
 924                         brelse(bh);
 925                         bh = NULL;
 926
 927                         /*
 928                          * XXX: do we need to empty all the following
 929                          * blocks in this cluster?
 930                          */
 931                         if (!value_len)
 932                                 break;
 933                 }
 934                 cpos += num_clusters;
 935         }
 936 out_commit:
 937         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 938 out:
 939         brelse(bh);
 940
 941         return ret;
 942 }
 943
 944 static int ocfs2_xattr_cleanup(struct inode *inode,
 945                                struct ocfs2_xattr_info *xi,
 946                                struct ocfs2_xattr_search *xs,
 947                                size_t offs)
 948 {
 949         handle_t *handle = NULL;
 950         int ret = 0;
 951         size_t name_len = strlen(xi->name);
 952         void *val = xs->base + offs;
 953         size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
 954
 955         handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
 956                                    OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
 957         if (IS_ERR(handle)) {
 958                 ret = PTR_ERR(handle);
 959                 mlog_errno(ret);
 960                 goto out;
 961         }
 962         ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
 963                                    OCFS2_JOURNAL_ACCESS_WRITE);
 964         if (ret) {
 965                 mlog_errno(ret);
 966                 goto out_commit;
 967         }
 968         /* Decrease xattr count */
 969         le16_add_cpu(&xs->header->xh_count, -1);
 970         /* Remove the xattr entry and tree root which has already be set*/
 971         memset((void *)xs->here, 0, sizeof(struct ocfs2_xattr_entry));
 972         memset(val, 0, size);
 973
 974         ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
 975         if (ret < 0)
 976                 mlog_errno(ret);
 977 out_commit:
 978         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 979 out:
 980         return ret;
 981 }
 982
 983 static int ocfs2_xattr_update_entry(struct inode *inode,
 984                                     struct ocfs2_xattr_info *xi,
 985                                     struct ocfs2_xattr_search *xs,
 986                                     size_t offs)
 987 {
 988         handle_t *handle = NULL;
 989         int ret = 0;
 990
 991         handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
 992                                    OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
 993         if (IS_ERR(handle)) {
 994                 ret = PTR_ERR(handle);
 995                 mlog_errno(ret);
 996                 goto out;
 997         }
 998         ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
 999                                    OCFS2_JOURNAL_ACCESS_WRITE);
1000         if (ret) {
1001                 mlog_errno(ret);
1002                 goto out_commit;
1003         }
1004
1005         xs->here->xe_name_offset = cpu_to_le16(offs);
1006         xs->here->xe_value_size = cpu_to_le64(xi->value_len);
1007         if (xi->value_len <= OCFS2_XATTR_INLINE_SIZE)
1008                 ocfs2_xattr_set_local(xs->here, 1);
1009         else
1010                 ocfs2_xattr_set_local(xs->here, 0);
1011         ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
1012
1013         ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
1014         if (ret < 0)
1015                 mlog_errno(ret);
1016 out_commit:
1017         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
1018 out:
1019         return ret;
1020 }
1021
1022 /*
1023  * ocfs2_xattr_set_value_outside()
1024  *
1025  * Set large size value in B tree.
1026  */
1027 static int ocfs2_xattr_set_value_outside(struct inode *inode,
1028                                          struct ocfs2_xattr_info *xi,
1029                                          struct ocfs2_xattr_search *xs,
1030                                          size_t offs)
1031 {
1032         size_t name_len = strlen(xi->name);
1033         void *val = xs->base + offs;
1034         struct ocfs2_xattr_value_root *xv = NULL;
1035         size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
1036         int ret = 0;
1037
1038         memset(val, 0, size);
1039         memcpy(val, xi->name, name_len);
1040         xv = (struct ocfs2_xattr_value_root *)
1041                 (val + OCFS2_XATTR_SIZE(name_len));
1042         xv->xr_clusters = 0;
1043         xv->xr_last_eb_blk = 0;
1044         xv->xr_list.l_tree_depth = 0;
1045         xv->xr_list.l_count = cpu_to_le16(1);
1046         xv->xr_list.l_next_free_rec = 0;
1047
1048         ret = ocfs2_xattr_value_truncate(inode, xs->xattr_bh, xv,
1049                                          xi->value_len);
1050         if (ret < 0) {
1051                 mlog_errno(ret);
1052                 return ret;
1053         }
1054         ret = __ocfs2_xattr_set_value_outside(inode, xv, xi->value,
1055                                               xi->value_len);
1056         if (ret < 0) {
1057                 mlog_errno(ret);
1058                 return ret;
1059         }
1060         ret = ocfs2_xattr_update_entry(inode, xi, xs, offs);
1061         if (ret < 0)
1062                 mlog_errno(ret);
1063
1064         return ret;
1065 }
1066
1067 /*
1068  * ocfs2_xattr_set_entry_local()
1069  *
1070  * Set, replace or remove extended attribute in local.
1071  */
1072 static void ocfs2_xattr_set_entry_local(struct inode *inode,
1073                                         struct ocfs2_xattr_info *xi,
1074                                         struct ocfs2_xattr_search *xs,
1075                                         struct ocfs2_xattr_entry *last,
1076                                         size_t min_offs)
1077 {
1078         size_t name_len = strlen(xi->name);
1079         int i;
1080
1081         if (xi->value && xs->not_found) {
1082                 /* Insert the new xattr entry. */
1083                 le16_add_cpu(&xs->header->xh_count, 1);
1084                 ocfs2_xattr_set_type(last, xi->name_index);
1085                 ocfs2_xattr_set_local(last, 1);
1086                 last->xe_name_len = name_len;
1087         } else {
1088                 void *first_val;
1089                 void *val;
1090                 size_t offs, size;
1091
1092                 first_val = xs->base + min_offs;
1093                 offs = le16_to_cpu(xs->here->xe_name_offset);
1094                 val = xs->base + offs;
1095
1096                 if (le64_to_cpu(xs->here->xe_value_size) >
1097                     OCFS2_XATTR_INLINE_SIZE)
1098                         size = OCFS2_XATTR_SIZE(name_len) +
1099                                 OCFS2_XATTR_ROOT_SIZE;
1100                 else
1101                         size = OCFS2_XATTR_SIZE(name_len) +
1102                         OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
1103
1104                 if (xi->value && size == OCFS2_XATTR_SIZE(name_len) +
1105                                 OCFS2_XATTR_SIZE(xi->value_len)) {
1106                         /* The old and the new value have the
1107                            same size. Just replace the value. */
1108                         ocfs2_xattr_set_local(xs->here, 1);
1109                         xs->here->xe_value_size = cpu_to_le64(xi->value_len);
1110                         /* Clear value bytes. */
1111                         memset(val + OCFS2_XATTR_SIZE(name_len),
1112                                0,
1113                                OCFS2_XATTR_SIZE(xi->value_len));
1114                         memcpy(val + OCFS2_XATTR_SIZE(name_len),
1115                                xi->value,
1116                                xi->value_len);
1117                         return;
1118                 }
1119                 /* Remove the old name+value. */
1120                 memmove(first_val + size, first_val, val - first_val);
1121                 memset(first_val, 0, size);
1122                 xs->here->xe_name_hash = 0;
1123                 xs->here->xe_name_offset = 0;
1124                 ocfs2_xattr_set_local(xs->here, 1);
1125                 xs->here->xe_value_size = 0;
1126
1127                 min_offs += size;
1128
1129                 /* Adjust all value offsets. */
1130                 last = xs->header->xh_entries;
1131                 for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
1132                         size_t o = le16_to_cpu(last->xe_name_offset);
1133
1134                         if (o < offs)
1135                                 last->xe_name_offset = cpu_to_le16(o + size);
1136                         last += 1;
1137                 }
1138
1139                 if (!xi->value) {
1140                         /* Remove the old entry. */
1141                         last -= 1;
1142                         memmove(xs->here, xs->here + 1,
1143                                 (void *)last - (void *)xs->here);
1144                         memset(last, 0, sizeof(struct ocfs2_xattr_entry));
1145                         le16_add_cpu(&xs->header->xh_count, -1);
1146                 }
1147         }
1148         if (xi->value) {
1149                 /* Insert the new name+value. */
1150                 size_t size = OCFS2_XATTR_SIZE(name_len) +
1151                                 OCFS2_XATTR_SIZE(xi->value_len);
1152                 void *val = xs->base + min_offs - size;
1153
1154                 xs->here->xe_name_offset = cpu_to_le16(min_offs - size);
1155                 memset(val, 0, size);
1156                 memcpy(val, xi->name, name_len);
1157                 memcpy(val + OCFS2_XATTR_SIZE(name_len),
1158                        xi->value,
1159                        xi->value_len);
1160                 xs->here->xe_value_size = cpu_to_le64(xi->value_len);
1161                 ocfs2_xattr_set_local(xs->here, 1);
1162                 ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
1163         }
1164
1165         return;
1166 }
1167
1168 /*
1169  * ocfs2_xattr_set_entry()
1170  *
1171  * Set extended attribute entry into inode or block.
1172  *
1173  * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
1174  * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
1175  * then set value in B tree with set_value_outside().
1176  */
1177 static int ocfs2_xattr_set_entry(struct inode *inode,
1178                                  struct ocfs2_xattr_info *xi,
1179                                  struct ocfs2_xattr_search *xs,
1180                                  int flag)
1181 {
1182         struct ocfs2_xattr_entry *last;
1183         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1184         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1185         size_t min_offs = xs->end - xs->base, name_len = strlen(xi->name);
1186         size_t size_l = 0;
1187         handle_t *handle = NULL;
1188         int free, i, ret;
1189         struct ocfs2_xattr_info xi_l = {
1190                 .name_index = xi->name_index,
1191                 .name = xi->name,
1192                 .value = xi->value,
1193                 .value_len = xi->value_len,
1194         };
1195
1196         /* Compute min_offs, last and free space. */
1197         last = xs->header->xh_entries;
1198
1199         for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
1200                 size_t offs = le16_to_cpu(last->xe_name_offset);
1201                 if (offs < min_offs)
1202                         min_offs = offs;
1203                 last += 1;
1204         }
1205
1206         free = min_offs - ((void *)last - xs->base) - sizeof(__u32);
1207         if (free < 0)
1208                 return -EFAULT;
1209
1210         if (!xs->not_found) {
1211                 size_t size = 0;
1212                 if (ocfs2_xattr_is_local(xs->here))
1213                         size = OCFS2_XATTR_SIZE(name_len) +
1214                         OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
1215                 else
1216                         size = OCFS2_XATTR_SIZE(name_len) +
1217                                 OCFS2_XATTR_ROOT_SIZE;
1218                 free += (size + sizeof(struct ocfs2_xattr_entry));
1219         }
1220         /* Check free space in inode or block */
1221         if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
1222                 if (free < sizeof(struct ocfs2_xattr_entry) +
1223                            OCFS2_XATTR_SIZE(name_len) +
1224                            OCFS2_XATTR_ROOT_SIZE) {
1225                         ret = -ENOSPC;
1226                         goto out;
1227                 }
1228                 size_l = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
1229                 xi_l.value = (void *)&def_xv;
1230                 xi_l.value_len = OCFS2_XATTR_ROOT_SIZE;
1231         } else if (xi->value) {
1232                 if (free < sizeof(struct ocfs2_xattr_entry) +
1233                            OCFS2_XATTR_SIZE(name_len) +
1234                            OCFS2_XATTR_SIZE(xi->value_len)) {
1235                         ret = -ENOSPC;
1236                         goto out;
1237                 }
1238         }
1239
1240         if (!xs->not_found) {
1241                 /* For existing extended attribute */
1242                 size_t size = OCFS2_XATTR_SIZE(name_len) +
1243                         OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
1244                 size_t offs = le16_to_cpu(xs->here->xe_name_offset);
1245                 void *val = xs->base + offs;
1246
1247                 if (ocfs2_xattr_is_local(xs->here) && size == size_l) {
1248                         /* Replace existing local xattr with tree root */
1249                         ret = ocfs2_xattr_set_value_outside(inode, xi, xs,
1250                                                             offs);
1251                         if (ret < 0)
1252                                 mlog_errno(ret);
1253                         goto out;
1254                 } else if (!ocfs2_xattr_is_local(xs->here)) {
1255                         /* For existing xattr which has value outside */
1256                         struct ocfs2_xattr_value_root *xv = NULL;
1257                         xv = (struct ocfs2_xattr_value_root *)(val +
1258                                 OCFS2_XATTR_SIZE(name_len));
1259
1260                         if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
1261                                 /*
1262                                  * If new value need set outside also,
1263                                  * first truncate old value to new value,
1264                                  * then set new value with set_value_outside().
1265                                  */
1266                                 ret = ocfs2_xattr_value_truncate(inode,
1267                                                                  xs->xattr_bh,
1268                                                                  xv,
1269                                                                  xi->value_len);
1270                                 if (ret < 0) {
1271                                         mlog_errno(ret);
1272                                         goto out;
1273                                 }
1274
1275                                 ret = __ocfs2_xattr_set_value_outside(inode,
1276                                                                 xv,
1277                                                                 xi->value,
1278                                                                 xi->value_len);
1279                                 if (ret < 0) {
1280                                         mlog_errno(ret);
1281                                         goto out;
1282                                 }
1283
1284                                 ret = ocfs2_xattr_update_entry(inode,
1285                                                                xi,
1286                                                                xs,
1287                                                                offs);
1288                                 if (ret < 0)
1289                                         mlog_errno(ret);
1290                                 goto out;
1291                         } else {
1292                                 /*
1293                                  * If new value need set in local,
1294                                  * just trucate old value to zero.
1295                                  */
1296                                  ret = ocfs2_xattr_value_truncate(inode,
1297                                                                  xs->xattr_bh,
1298                                                                  xv,
1299                                                                  0);
1300                                 if (ret < 0)
1301                                         mlog_errno(ret);
1302                         }
1303                 }
1304         }
1305
1306         handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
1307                                    OCFS2_INODE_UPDATE_CREDITS);
1308         if (IS_ERR(handle)) {
1309                 ret = PTR_ERR(handle);
1310                 mlog_errno(ret);
1311                 goto out;
1312         }
1313
1314         ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
1315                                    OCFS2_JOURNAL_ACCESS_WRITE);
1316         if (ret) {
1317                 mlog_errno(ret);
1318                 goto out_commit;
1319         }
1320
1321         if (!(flag & OCFS2_INLINE_XATTR_FL)) {
1322                 /*set extended attribue in external blcok*/
1323                 ret = ocfs2_extend_trans(handle,
1324                                          OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
1325                 if (ret) {
1326                         mlog_errno(ret);
1327                         goto out_commit;
1328                 }
1329                 ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
1330                                            OCFS2_JOURNAL_ACCESS_WRITE);
1331                 if (ret) {
1332                         mlog_errno(ret);
1333                         goto out_commit;
1334                 }
1335         }
1336
1337         /*
1338          * Set value in local, include set tree root in local.
1339          * This is the first step for value size >INLINE_SIZE.
1340          */
1341         ocfs2_xattr_set_entry_local(inode, &xi_l, xs, last, min_offs);
1342
1343         if (!(flag & OCFS2_INLINE_XATTR_FL)) {
1344                 ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
1345                 if (ret < 0) {
1346                         mlog_errno(ret);
1347                         goto out_commit;
1348                 }
1349         }
1350
1351         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) &&
1352             (flag & OCFS2_INLINE_XATTR_FL)) {
1353                 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1354                 unsigned int xattrsize = osb->s_xattr_inline_size;
1355
1356                 /*
1357                  * Adjust extent record count or inline data size
1358                  * to reserve space for extended attribute.
1359                  */
1360                 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1361                         struct ocfs2_inline_data *idata = &di->id2.i_data;
1362                         le16_add_cpu(&idata->id_count, -xattrsize);
1363                 } else if (!(ocfs2_inode_is_fast_symlink(inode))) {
1364                         struct ocfs2_extent_list *el = &di->id2.i_list;
1365                         le16_add_cpu(&el->l_count, -(xattrsize /
1366                                         sizeof(struct ocfs2_extent_rec)));
1367                 }
1368                 di->i_xattr_inline_size = cpu_to_le16(xattrsize);
1369         }
1370         /* Update xattr flag */
1371         spin_lock(&oi->ip_lock);
1372         oi->ip_dyn_features |= flag;
1373         di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
1374         spin_unlock(&oi->ip_lock);
1375         /* Update inode ctime */
1376         inode->i_ctime = CURRENT_TIME;
1377         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
1378         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
1379
1380         ret = ocfs2_journal_dirty(handle, xs->inode_bh);
1381         if (ret < 0)
1382                 mlog_errno(ret);
1383
1384 out_commit:
1385         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
1386
1387         if (!ret && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
1388                 /*
1389                  * Set value outside in B tree.
1390                  * This is the second step for value size > INLINE_SIZE.
1391                  */
1392                 size_t offs = le16_to_cpu(xs->here->xe_name_offset);
1393                 ret = ocfs2_xattr_set_value_outside(inode, xi, xs, offs);
1394                 if (ret < 0) {
1395                         int ret2;
1396
1397                         mlog_errno(ret);
1398                         /*
1399                          * If set value outside failed, we have to clean
1400                          * the junk tree root we have already set in local.
1401                          */
1402                         ret2 = ocfs2_xattr_cleanup(inode, xi, xs, offs);
1403                         if (ret2 < 0)
1404                                 mlog_errno(ret2);
1405                 }
1406         }
1407 out:
1408         return ret;
1409
1410 }
1411
1412 static int ocfs2_xattr_free_block(handle_t *handle,
1413                                   struct ocfs2_super *osb,
1414                                   struct ocfs2_xattr_block *xb)
1415 {
1416         struct inode *xb_alloc_inode;
1417         struct buffer_head *xb_alloc_bh = NULL;
1418         u64 blk = le64_to_cpu(xb->xb_blkno);
1419         u16 bit = le16_to_cpu(xb->xb_suballoc_bit);
1420         u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
1421         int ret = 0;
1422
1423         xb_alloc_inode = ocfs2_get_system_file_inode(osb,
1424                                 EXTENT_ALLOC_SYSTEM_INODE,
1425                                 le16_to_cpu(xb->xb_suballoc_slot));
1426         if (!xb_alloc_inode) {
1427                 ret = -ENOMEM;
1428                 mlog_errno(ret);
1429                 goto out;
1430         }
1431         mutex_lock(&xb_alloc_inode->i_mutex);
1432
1433         ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
1434         if (ret < 0) {
1435                 mlog_errno(ret);
1436                 goto out_mutex;
1437         }
1438         ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
1439         if (ret < 0) {
1440                 mlog_errno(ret);
1441                 goto out_unlock;
1442         }
1443         ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh,
1444                                        bit, bg_blkno, 1);
1445         if (ret < 0)
1446                 mlog_errno(ret);
1447 out_unlock:
1448         ocfs2_inode_unlock(xb_alloc_inode, 1);
1449         brelse(xb_alloc_bh);
1450 out_mutex:
1451         mutex_unlock(&xb_alloc_inode->i_mutex);
1452         iput(xb_alloc_inode);
1453 out:
1454         return ret;
1455 }
1456
1457 static int ocfs2_remove_value_outside(struct inode*inode,
1458                                       struct buffer_head *bh,
1459                                       struct ocfs2_xattr_header *header)
1460 {
1461         int ret = 0, i;
1462
1463         for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
1464                 struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
1465
1466                 if (!ocfs2_xattr_is_local(entry)) {
1467                         struct ocfs2_xattr_value_root *xv;
1468                         void *val;
1469
1470                         val = (void *)header +
1471                                 le16_to_cpu(entry->xe_name_offset);
1472                         xv = (struct ocfs2_xattr_value_root *)
1473                                 (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
1474                         ret = ocfs2_xattr_value_truncate(inode, bh, xv, 0);
1475                         if (ret < 0) {
1476                                 mlog_errno(ret);
1477                                 return ret;
1478                         }
1479                 }
1480         }
1481
1482         return ret;
1483 }
1484
1485 static int ocfs2_xattr_ibody_remove(struct inode *inode,
1486                                     struct buffer_head *di_bh)
1487 {
1488
1489         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1490         struct ocfs2_xattr_header *header;
1491         int ret;
1492
1493         header = (struct ocfs2_xattr_header *)
1494                  ((void *)di + inode->i_sb->s_blocksize -
1495                  le16_to_cpu(di->i_xattr_inline_size));
1496
1497         ret = ocfs2_remove_value_outside(inode, di_bh, header);
1498
1499         return ret;
1500 }
1501
1502 static int ocfs2_xattr_block_remove(struct inode *inode,
1503                                     struct buffer_head *blk_bh)
1504 {
1505         struct ocfs2_xattr_block *xb;
1506         struct ocfs2_xattr_header *header;
1507         int ret = 0;
1508
1509         xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
1510         header = &(xb->xb_attrs.xb_header);
1511
1512         ret = ocfs2_remove_value_outside(inode, blk_bh, header);
1513
1514         return ret;
1515 }
1516
1517 /*
1518  * ocfs2_xattr_remove()
1519  *
1520  * Free extended attribute resources associated with this inode.
1521  */
1522 int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
1523 {
1524         struct ocfs2_xattr_block *xb;
1525         struct buffer_head *blk_bh = NULL;
1526         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1527         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1528         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1529         handle_t *handle;
1530         int ret;
1531
1532         if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
1533                 return 0;
1534
1535         if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
1536                 ret = ocfs2_xattr_ibody_remove(inode, di_bh);
1537                 if (ret < 0) {
1538                         mlog_errno(ret);
1539                         goto out;
1540                 }
1541         }
1542         if (di->i_xattr_loc) {
1543                 ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
1544                                        le64_to_cpu(di->i_xattr_loc),
1545                                        &blk_bh, OCFS2_BH_CACHED, inode);
1546                 if (ret < 0) {
1547                         mlog_errno(ret);
1548                         return ret;
1549                 }
1550                 /*Verify the signature of xattr block*/
1551                 if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
1552                            strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
1553                         ret = -EFAULT;
1554                         goto out;
1555                 }
1556
1557                 ret = ocfs2_xattr_block_remove(inode, blk_bh);
1558                 if (ret < 0) {
1559                         mlog_errno(ret);
1560                         goto out;
1561                 }
1562         }
1563
1564         handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
1565                                    OCFS2_INODE_UPDATE_CREDITS);
1566         if (IS_ERR(handle)) {
1567                 ret = PTR_ERR(handle);
1568                 mlog_errno(ret);
1569                 goto out;
1570         }
1571         ret = ocfs2_journal_access(handle, inode, di_bh,
1572                                    OCFS2_JOURNAL_ACCESS_WRITE);
1573         if (ret) {
1574                 mlog_errno(ret);
1575                 goto out_commit;
1576         }
1577
1578         if (di->i_xattr_loc) {
1579                 xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
1580                 ocfs2_xattr_free_block(handle, osb, xb);
1581                 di->i_xattr_loc = cpu_to_le64(0);
1582         }
1583
1584         spin_lock(&oi->ip_lock);
1585         oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
1586         di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
1587         spin_unlock(&oi->ip_lock);
1588
1589         ret = ocfs2_journal_dirty(handle, di_bh);
1590         if (ret < 0)
1591                 mlog_errno(ret);
1592 out_commit:
1593         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
1594 out:
1595         brelse(blk_bh);
1596
1597         return ret;
1598 }
1599
1600 static int ocfs2_xattr_has_space_inline(struct inode *inode,
1601                                         struct ocfs2_dinode *di)
1602 {
1603         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1604         unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
1605         int free;
1606
1607         if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE)
1608                 return 0;
1609
1610         if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1611                 struct ocfs2_inline_data *idata = &di->id2.i_data;
1612                 free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size);
1613         } else if (ocfs2_inode_is_fast_symlink(inode)) {
1614                 free = ocfs2_fast_symlink_chars(inode->i_sb) -
1615                         le64_to_cpu(di->i_size);
1616         } else {
1617                 struct ocfs2_extent_list *el = &di->id2.i_list;
1618                 free = (le16_to_cpu(el->l_count) -
1619                         le16_to_cpu(el->l_next_free_rec)) *
1620                         sizeof(struct ocfs2_extent_rec);
1621         }
1622         if (free >= xattrsize)
1623                 return 1;
1624
1625         return 0;
1626 }
1627
1628 /*
1629  * ocfs2_xattr_ibody_find()
1630  *
1631  * Find extended attribute in inode block and
1632  * fill search info into struct ocfs2_xattr_search.
1633  */
1634 static int ocfs2_xattr_ibody_find(struct inode *inode,
1635                                   int name_index,
1636                                   const char *name,
1637                                   struct ocfs2_xattr_search *xs)
1638 {
1639         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1640         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1641         int ret;
1642         int has_space = 0;
1643
1644         if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
1645                 return 0;
1646
1647         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
1648                 down_read(&oi->ip_alloc_sem);
1649                 has_space = ocfs2_xattr_has_space_inline(inode, di);
1650                 up_read(&oi->ip_alloc_sem);
1651                 if (!has_space)
1652                         return 0;
1653         }
1654
1655         xs->xattr_bh = xs->inode_bh;
1656         xs->end = (void *)di + inode->i_sb->s_blocksize;
1657         if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
1658                 xs->header = (struct ocfs2_xattr_header *)
1659                         (xs->end - le16_to_cpu(di->i_xattr_inline_size));
1660         else
1661                 xs->header = (struct ocfs2_xattr_header *)
1662                         (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size);
1663         xs->base = (void *)xs->header;
1664         xs->here = xs->header->xh_entries;
1665
1666         /* Find the named attribute. */
1667         if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
1668                 ret = ocfs2_xattr_find_entry(name_index, name, xs);
1669                 if (ret && ret != -ENODATA)
1670                         return ret;
1671                 xs->not_found = ret;
1672         }
1673
1674         return 0;
1675 }
1676
1677 /*
1678  * ocfs2_xattr_ibody_set()
1679  *
1680  * Set, replace or remove an extended attribute into inode block.
1681  *
1682  */
1683 static int ocfs2_xattr_ibody_set(struct inode *inode,
1684                                  struct ocfs2_xattr_info *xi,
1685                                  struct ocfs2_xattr_search *xs)
1686 {
1687         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1688         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1689         int ret;
1690
1691         if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
1692                 return -ENOSPC;
1693
1694         down_write(&oi->ip_alloc_sem);
1695         if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
1696                 if (!ocfs2_xattr_has_space_inline(inode, di)) {
1697                         ret = -ENOSPC;
1698                         goto out;
1699                 }
1700         }
1701
1702         ret = ocfs2_xattr_set_entry(inode, xi, xs,
1703                                 (OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL));
1704 out:
1705         up_write(&oi->ip_alloc_sem);
1706
1707         return ret;
1708 }
1709
1710 /*
1711  * ocfs2_xattr_block_find()
1712  *
1713  * Find extended attribute in external block and
1714  * fill search info into struct ocfs2_xattr_search.
1715  */
1716 static int ocfs2_xattr_block_find(struct inode *inode,
1717                                   int name_index,
1718                                   const char *name,
1719                                   struct ocfs2_xattr_search *xs)
1720 {
1721         struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
1722         struct buffer_head *blk_bh = NULL;
1723         struct ocfs2_xattr_block *xb;
1724         int ret = 0;
1725
1726         if (!di->i_xattr_loc)
1727                 return ret;
1728
1729         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
1730                                le64_to_cpu(di->i_xattr_loc),
1731                                &blk_bh, OCFS2_BH_CACHED, inode);
1732         if (ret < 0) {
1733                 mlog_errno(ret);
1734                 return ret;
1735         }
1736         /*Verify the signature of xattr block*/
1737         if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
1738                    strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
1739                         ret = -EFAULT;
1740                         goto cleanup;
1741         }
1742
1743         xs->xattr_bh = blk_bh;
1744         xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
1745
1746         if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
1747                 xs->header = &xb->xb_attrs.xb_header;
1748                 xs->base = (void *)xs->header;
1749                 xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
1750                 xs->here = xs->header->xh_entries;
1751
1752                 ret = ocfs2_xattr_find_entry(name_index, name, xs);
1753         } else
1754                 ret = ocfs2_xattr_index_block_find(inode, blk_bh,
1755                                                    name_index,
1756                                                    name, xs);
1757
1758         if (ret && ret != -ENODATA) {
1759                 xs->xattr_bh = NULL;
1760                 goto cleanup;
1761         }
1762         xs->not_found = ret;
1763         return 0;
1764 cleanup:
1765         brelse(blk_bh);
1766
1767         return ret;
1768 }
1769
1770 /*
1771  * ocfs2_xattr_block_set()
1772  *
1773  * Set, replace or remove an extended attribute into external block.
1774  *
1775  */
1776 static int ocfs2_xattr_block_set(struct inode *inode,
1777                                  struct ocfs2_xattr_info *xi,
1778                                  struct ocfs2_xattr_search *xs)
1779 {
1780         struct buffer_head *new_bh = NULL;
1781         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1782         struct ocfs2_dinode *di =  (struct ocfs2_dinode *)xs->inode_bh->b_data;
1783         struct ocfs2_alloc_context *meta_ac = NULL;
1784         handle_t *handle = NULL;
1785         struct ocfs2_xattr_block *xblk = NULL;
1786         u16 suballoc_bit_start;
1787         u32 num_got;
1788         u64 first_blkno;
1789         int ret;
1790
1791         if (!xs->xattr_bh) {
1792                 /*
1793                  * Alloc one external block for extended attribute
1794                  * outside of inode.
1795                  */
1796                 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
1797                 if (ret < 0) {
1798                         mlog_errno(ret);
1799                         goto out;
1800                 }
1801                 handle = ocfs2_start_trans(osb,
1802                                            OCFS2_XATTR_BLOCK_CREATE_CREDITS);
1803                 if (IS_ERR(handle)) {
1804                         ret = PTR_ERR(handle);
1805                         mlog_errno(ret);
1806                         goto out;
1807                 }
1808                 ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
1809                                            OCFS2_JOURNAL_ACCESS_CREATE);
1810                 if (ret < 0) {
1811                         mlog_errno(ret);
1812                         goto out_commit;
1813                 }
1814
1815                 ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
1816                                            &suballoc_bit_start, &num_got,
1817                                            &first_blkno);
1818                 if (ret < 0) {
1819                         mlog_errno(ret);
1820                         goto out_commit;
1821                 }
1822
1823                 new_bh = sb_getblk(inode->i_sb, first_blkno);
1824                 ocfs2_set_new_buffer_uptodate(inode, new_bh);
1825
1826                 ret = ocfs2_journal_access(handle, inode, new_bh,
1827                                            OCFS2_JOURNAL_ACCESS_CREATE);
1828                 if (ret < 0) {
1829                         mlog_errno(ret);
1830                         goto out_commit;
1831                 }
1832
1833                 /* Initialize ocfs2_xattr_block */
1834                 xs->xattr_bh = new_bh;
1835                 xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
1836                 memset(xblk, 0, inode->i_sb->s_blocksize);
1837                 strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
1838                 xblk->xb_suballoc_slot = cpu_to_le16(osb->slot_num);
1839                 xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1840                 xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation);
1841                 xblk->xb_blkno = cpu_to_le64(first_blkno);
1842
1843                 xs->header = &xblk->xb_attrs.xb_header;
1844                 xs->base = (void *)xs->header;
1845                 xs->end = (void *)xblk + inode->i_sb->s_blocksize;
1846                 xs->here = xs->header->xh_entries;
1847
1848
1849                 ret = ocfs2_journal_dirty(handle, new_bh);
1850                 if (ret < 0) {
1851                         mlog_errno(ret);
1852                         goto out_commit;
1853                 }
1854                 di->i_xattr_loc = cpu_to_le64(first_blkno);
1855                 ret = ocfs2_journal_dirty(handle, xs->inode_bh);
1856                 if (ret < 0)
1857                         mlog_errno(ret);
1858 out_commit:
1859                 ocfs2_commit_trans(osb, handle);
1860 out:
1861                 if (meta_ac)
1862                         ocfs2_free_alloc_context(meta_ac);
1863                 if (ret < 0)
1864                         return ret;
1865         }
1866
1867         /* Set extended attribute into external block */
1868         ret = ocfs2_xattr_set_entry(inode, xi, xs, OCFS2_HAS_XATTR_FL);
1869
1870         return ret;
1871 }
1872
1873 /*
1874  * ocfs2_xattr_set()
1875  *
1876  * Set, replace or remove an extended attribute for this inode.
1877  * value is NULL to remove an existing extended attribute, else either
1878  * create or replace an extended attribute.
1879  */
1880 int ocfs2_xattr_set(struct inode *inode,
1881                     int name_index,
1882                     const char *name,
1883                     const void *value,
1884                     size_t value_len,
1885                     int flags)
1886 {
1887         struct buffer_head *di_bh = NULL;
1888         struct ocfs2_dinode *di;
1889         int ret;
1890
1891         struct ocfs2_xattr_info xi = {
1892                 .name_index = name_index,
1893                 .name = name,
1894                 .value = value,
1895                 .value_len = value_len,
1896         };
1897
1898         struct ocfs2_xattr_search xis = {
1899                 .not_found = -ENODATA,
1900         };
1901
1902         struct ocfs2_xattr_search xbs = {
1903                 .not_found = -ENODATA,
1904         };
1905
1906         ret = ocfs2_inode_lock(inode, &di_bh, 1);
1907         if (ret < 0) {
1908                 mlog_errno(ret);
1909                 return ret;
1910         }
1911         xis.inode_bh = xbs.inode_bh = di_bh;
1912         di = (struct ocfs2_dinode *)di_bh->b_data;
1913
1914         down_write(&OCFS2_I(inode)->ip_xattr_sem);
1915         /*
1916          * Scan inode and external block to find the same name
1917          * extended attribute and collect search infomation.
1918          */
1919         ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
1920         if (ret)
1921                 goto cleanup;
1922         if (xis.not_found) {
1923                 ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
1924                 if (ret)
1925                         goto cleanup;
1926         }
1927
1928         if (xis.not_found && xbs.not_found) {
1929                 ret = -ENODATA;
1930                 if (flags & XATTR_REPLACE)
1931                         goto cleanup;
1932                 ret = 0;
1933                 if (!value)
1934                         goto cleanup;
1935         } else {
1936                 ret = -EEXIST;
1937                 if (flags & XATTR_CREATE)
1938                         goto cleanup;
1939         }
1940
1941         if (!value) {
1942                 /* Remove existing extended attribute */
1943                 if (!xis.not_found)
1944                         ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
1945                 else if (!xbs.not_found)
1946                         ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
1947         } else {
1948                 /* We always try to set extended attribute into inode first*/
1949                 ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
1950                 if (!ret && !xbs.not_found) {
1951                         /*
1952                          * If succeed and that extended attribute existing in
1953                          * external block, then we will remove it.
1954                          */
1955                         xi.value = NULL;
1956                         xi.value_len = 0;
1957                         ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
1958                 } else if (ret == -ENOSPC) {
1959                         if (di->i_xattr_loc && !xbs.xattr_bh) {
1960                                 ret = ocfs2_xattr_block_find(inode, name_index,
1961                                                              name, &xbs);
1962                                 if (ret)
1963                                         goto cleanup;
1964                         }
1965                         /*
1966                          * If no space in inode, we will set extended attribute
1967                          * into external block.
1968                          */
1969                         ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
1970                         if (ret)
1971                                 goto cleanup;
1972                         if (!xis.not_found) {
1973                                 /*
1974                                  * If succeed and that extended attribute
1975                                  * existing in inode, we will remove it.
1976                                  */
1977                                 xi.value = NULL;
1978                                 xi.value_len = 0;
1979                                 ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
1980                         }
1981                 }
1982         }
1983 cleanup:
1984         up_write(&OCFS2_I(inode)->ip_xattr_sem);
1985         ocfs2_inode_unlock(inode, 1);
1986         brelse(di_bh);
1987         brelse(xbs.xattr_bh);
1988
1989         return ret;
1990 }
1991
1992 static inline u32 ocfs2_xattr_hash_by_name(struct inode *inode,
1993                                            int name_index,
1994                                            const char *suffix_name)
1995 {
1996         struct xattr_handler *handler = ocfs2_xattr_handler(name_index);
1997         char *prefix = handler->prefix;
1998         int prefix_len = strlen(handler->prefix);
1999
2000         return ocfs2_xattr_name_hash(inode, prefix, prefix_len,
2001                                      (char *)suffix_name, strlen(suffix_name));
2002 }
2003
2004 /*
2005  * Find the xattr extent rec which may contains name_hash.
2006  * e_cpos will be the first name hash of the xattr rec.
2007  * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
2008  */
2009 static int ocfs2_xattr_get_rec(struct inode *inode,
2010                                u32 name_hash,
2011                                u64 *p_blkno,
2012                                u32 *e_cpos,
2013                                u32 *num_clusters,
2014                                struct ocfs2_extent_list *el)
2015 {
2016         int ret = 0, i;
2017         struct buffer_head *eb_bh = NULL;
2018         struct ocfs2_extent_block *eb;
2019         struct ocfs2_extent_rec *rec = NULL;
2020         u64 e_blkno = 0;
2021
2022         if (el->l_tree_depth) {
2023                 ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh);
2024                 if (ret) {
2025                         mlog_errno(ret);
2026                         goto out;
2027                 }
2028
2029                 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
2030                 el = &eb->h_list;
2031
2032                 if (el->l_tree_depth) {
2033                         ocfs2_error(inode->i_sb,
2034                                     "Inode %lu has non zero tree depth in "
2035                                     "xattr tree block %llu\n", inode->i_ino,
2036                                     (unsigned long long)eb_bh->b_blocknr);
2037                         ret = -EROFS;
2038                         goto out;
2039                 }
2040         }
2041
2042         for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
2043                 rec = &el->l_recs[i];
2044
2045                 if (le32_to_cpu(rec->e_cpos) <= name_hash) {
2046                         e_blkno = le64_to_cpu(rec->e_blkno);
2047                         break;
2048                 }
2049         }
2050
2051         if (!e_blkno) {
2052                 ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
2053                             "record (%u, %u, 0) in xattr", inode->i_ino,
2054                             le32_to_cpu(rec->e_cpos),
2055                             ocfs2_rec_clusters(el, rec));
2056                 ret = -EROFS;
2057                 goto out;
2058         }
2059
2060         *p_blkno = le64_to_cpu(rec->e_blkno);
2061         *num_clusters = le16_to_cpu(rec->e_leaf_clusters);
2062         if (e_cpos)
2063                 *e_cpos = le32_to_cpu(rec->e_cpos);
2064 out:
2065         brelse(eb_bh);
2066         return ret;
2067 }
2068
2069 typedef int (xattr_bucket_func)(struct inode *inode,
2070                                 struct ocfs2_xattr_bucket *bucket,
2071                                 void *para);
2072
2073 static int ocfs2_find_xe_in_bucket(struct inode *inode,
2074                                    struct buffer_head *header_bh,
2075                                    int name_index,
2076                                    const char *name,
2077                                    u32 name_hash,
2078                                    u16 *xe_index,
2079                                    int *found)
2080 {
2081         int i, ret = 0, cmp = 1, block_off, new_offset;
2082         struct ocfs2_xattr_header *xh =
2083                         (struct ocfs2_xattr_header *)header_bh->b_data;
2084         size_t name_len = strlen(name);
2085         struct ocfs2_xattr_entry *xe = NULL;
2086         struct buffer_head *name_bh = NULL;
2087         char *xe_name;
2088
2089         /*
2090          * We don't use binary search in the bucket because there
2091          * may be multiple entries with the same name hash.
2092          */
2093         for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
2094                 xe = &xh->xh_entries[i];
2095
2096                 if (name_hash > le32_to_cpu(xe->xe_name_hash))
2097                         continue;
2098                 else if (name_hash < le32_to_cpu(xe->xe_name_hash))
2099                         break;
2100
2101                 cmp = name_index - ocfs2_xattr_get_type(xe);
2102                 if (!cmp)
2103                         cmp = name_len - xe->xe_name_len;
2104                 if (cmp)
2105                         continue;
2106
2107                 ret = ocfs2_xattr_bucket_get_name_value(inode,
2108                                                         xh,
2109                                                         i,
2110                                                         &block_off,
2111                                                         &new_offset);
2112                 if (ret) {
2113                         mlog_errno(ret);
2114                         break;
2115                 }
2116
2117                 ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
2118                                        header_bh->b_blocknr + block_off,
2119                                        &name_bh, OCFS2_BH_CACHED, inode);
2120                 if (ret) {
2121                         mlog_errno(ret);
2122                         break;
2123                 }
2124                 xe_name = name_bh->b_data + new_offset;
2125
2126                 cmp = memcmp(name, xe_name, name_len);
2127                 brelse(name_bh);
2128                 name_bh = NULL;
2129
2130                 if (cmp == 0) {
2131                         *xe_index = i;
2132                         *found = 1;
2133                         ret = 0;
2134                         break;
2135                 }
2136         }
2137
2138         return ret;
2139 }
2140
2141 /*
2142  * Find the specified xattr entry in a series of buckets.
2143  * This series start from p_blkno and last for num_clusters.
2144  * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
2145  * the num of the valid buckets.
2146  *
2147  * Return the buffer_head this xattr should reside in. And if the xattr's
2148  * hash is in the gap of 2 buckets, return the lower bucket.
2149  */
2150 static int ocfs2_xattr_bucket_find(struct inode *inode,
2151                                    int name_index,
2152                                    const char *name,
2153                                    u32 name_hash,
2154                                    u64 p_blkno,
2155                                    u32 first_hash,
2156                                    u32 num_clusters,
2157                                    struct ocfs2_xattr_search *xs)
2158 {
2159         int ret, found = 0;
2160         struct buffer_head *bh = NULL;
2161         struct buffer_head *lower_bh = NULL;
2162         struct ocfs2_xattr_header *xh = NULL;
2163         struct ocfs2_xattr_entry *xe = NULL;
2164         u16 index = 0;
2165         u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
2166         int low_bucket = 0, bucket, high_bucket;
2167         u32 last_hash;
2168         u64 blkno;
2169
2170         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno,
2171                                &bh, OCFS2_BH_CACHED, inode);
2172         if (ret) {
2173                 mlog_errno(ret);
2174                 goto out;
2175         }
2176
2177         xh = (struct ocfs2_xattr_header *)bh->b_data;
2178         high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
2179
2180         while (low_bucket <= high_bucket) {
2181                 brelse(bh);
2182                 bh = NULL;
2183                 bucket = (low_bucket + high_bucket) / 2;
2184
2185                 blkno = p_blkno + bucket * blk_per_bucket;
2186
2187                 ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
2188                                        &bh, OCFS2_BH_CACHED, inode);
2189                 if (ret) {
2190                         mlog_errno(ret);
2191                         goto out;
2192                 }
2193
2194                 xh = (struct ocfs2_xattr_header *)bh->b_data;
2195                 xe = &xh->xh_entries[0];
2196                 if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
2197                         high_bucket = bucket - 1;
2198                         continue;
2199                 }
2200
2201                 /*
2202                  * Check whether the hash of the last entry in our
2203                  * bucket is larger than the search one.
2204                  */
2205                 xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1];
2206                 last_hash = le32_to_cpu(xe->xe_name_hash);
2207
2208                 /* record lower_bh which may be the insert place. */
2209                 brelse(lower_bh);
2210                 lower_bh = bh;
2211                 bh = NULL;
2212
2213                 if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
2214                         low_bucket = bucket + 1;
2215                         continue;
2216                 }
2217
2218                 /* the searched xattr should reside in this bucket if exists. */
2219                 ret = ocfs2_find_xe_in_bucket(inode, lower_bh,
2220                                               name_index, name, name_hash,
2221                                               &index, &found);
2222                 if (ret) {
2223                         mlog_errno(ret);
2224                         goto out;
2225                 }
2226                 break;
2227         }
2228
2229         /*
2230          * Record the bucket we have found.
2231          * When the xattr's hash value is in the gap of 2 buckets, we will
2232          * always set it to the previous bucket.
2233          */
2234         if (!lower_bh) {
2235                 /*
2236                  * We can't find any bucket whose first name_hash is less
2237                  * than the find name_hash.
2238                  */
2239                 BUG_ON(bh->b_blocknr != p_blkno);
2240                 lower_bh = bh;
2241                 bh = NULL;
2242         }
2243         xs->bucket.bhs[0] = lower_bh;
2244         xs->bucket.xh = (struct ocfs2_xattr_header *)
2245                                         xs->bucket.bhs[0]->b_data;
2246         lower_bh = NULL;
2247
2248         xs->header = xs->bucket.xh;
2249         xs->base = xs->bucket.bhs[0]->b_data;
2250         xs->end = xs->base + inode->i_sb->s_blocksize;
2251
2252         if (found) {
2253                 /*
2254                  * If we have found the xattr enty, read all the blocks in
2255                  * this bucket.
2256                  */
2257                 ret = ocfs2_read_blocks(OCFS2_SB(inode->i_sb),
2258                                         xs->bucket.bhs[0]->b_blocknr + 1,
2259                                         blk_per_bucket - 1, &xs->bucket.bhs[1],
2260                                         OCFS2_BH_CACHED, inode);
2261                 if (ret) {
2262                         mlog_errno(ret);
2263                         goto out;
2264                 }
2265
2266                 xs->here = &xs->header->xh_entries[index];
2267                 mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name,
2268                      (unsigned long long)xs->bucket.bhs[0]->b_blocknr, index);
2269         } else
2270                 ret = -ENODATA;
2271
2272 out:
2273         brelse(bh);
2274         brelse(lower_bh);
2275         return ret;
2276 }
2277
2278 static int ocfs2_xattr_index_block_find(struct inode *inode,
2279                                         struct buffer_head *root_bh,
2280                                         int name_index,
2281                                         const char *name,
2282                                         struct ocfs2_xattr_search *xs)
2283 {
2284         int ret;
2285         struct ocfs2_xattr_block *xb =
2286                         (struct ocfs2_xattr_block *)root_bh->b_data;
2287         struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
2288         struct ocfs2_extent_list *el = &xb_root->xt_list;
2289         u64 p_blkno = 0;
2290         u32 first_hash, num_clusters = 0;
2291         u32 name_hash = ocfs2_xattr_hash_by_name(inode, name_index, name);
2292
2293         if (le16_to_cpu(el->l_next_free_rec) == 0)
2294                 return -ENODATA;
2295
2296         mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
2297              name, name_hash, name_index);
2298
2299         ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash,
2300                                   &num_clusters, el);
2301         if (ret) {
2302                 mlog_errno(ret);
2303                 goto out;
2304         }
2305
2306         BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash);
2307
2308         mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
2309              "in the rec is %u\n", num_clusters, p_blkno, first_hash);
2310
2311         ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash,
2312                                       p_blkno, first_hash, num_clusters, xs);
2313
2314 out:
2315         return ret;
2316 }
2317
2318 static int ocfs2_iterate_xattr_buckets(struct inode *inode,
2319                                        u64 blkno,
2320                                        u32 clusters,
2321                                        xattr_bucket_func *func,
2322                                        void *para)
2323 {
2324         int i, j, ret = 0;
2325         int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
2326         u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
2327         u32 num_buckets = clusters * bpc;
2328         struct ocfs2_xattr_bucket bucket;
2329
2330         memset(&bucket, 0, sizeof(bucket));
2331
2332         mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
2333              clusters, blkno);
2334
2335         for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
2336                 ret = ocfs2_read_blocks(OCFS2_SB(inode->i_sb),
2337                                         blkno, blk_per_bucket,
2338                                         bucket.bhs, OCFS2_BH_CACHED, inode);
2339                 if (ret) {
2340                         mlog_errno(ret);
2341                         goto out;
2342                 }
2343
2344                 bucket.xh = (struct ocfs2_xattr_header *)bucket.bhs[0]->b_data;
2345                 /*
2346                  * The real bucket num in this series of blocks is stored
2347                  * in the 1st bucket.
2348                  */
2349                 if (i == 0)
2350                         num_buckets = le16_to_cpu(bucket.xh->xh_num_buckets);
2351
2352                 mlog(0, "iterating xattr bucket %llu\n", blkno);
2353                 if (func) {
2354                         ret = func(inode, &bucket, para);
2355                         if (ret) {
2356                                 mlog_errno(ret);
2357                                 break;
2358                         }
2359                 }
2360
2361                 for (j = 0; j < blk_per_bucket; j++)
2362                         brelse(bucket.bhs[j]);
2363                 memset(&bucket, 0, sizeof(bucket));
2364         }
2365
2366 out:
2367         for (j = 0; j < blk_per_bucket; j++)
2368                 brelse(bucket.bhs[j]);
2369
2370         return ret;
2371 }
2372
2373 struct ocfs2_xattr_tree_list {
2374         char *buffer;
2375         size_t buffer_size;
2376 };
2377
2378 static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
2379                                              struct ocfs2_xattr_header *xh,
2380                                              int index,
2381                                              int *block_off,
2382                                              int *new_offset)
2383 {
2384         u16 name_offset;
2385
2386         if (index < 0 || index >= le16_to_cpu(xh->xh_count))
2387                 return -EINVAL;
2388
2389         name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
2390
2391         *block_off = name_offset >> inode->i_sb->s_blocksize_bits;
2392         *new_offset = name_offset % inode->i_sb->s_blocksize;
2393
2394         return 0;
2395 }
2396
2397 static int ocfs2_list_xattr_bucket(struct inode *inode,
2398                                    struct ocfs2_xattr_bucket *bucket,
2399                                    void *para)
2400 {
2401         int ret = 0;
2402         struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
2403         size_t size;
2404         int i, block_off, new_offset;
2405
2406         for (i = 0 ; i < le16_to_cpu(bucket->xh->xh_count); i++) {
2407                 struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i];
2408                 struct xattr_handler *handler =
2409                         ocfs2_xattr_handler(ocfs2_xattr_get_type(entry));
2410
2411                 if (handler) {
2412                         ret = ocfs2_xattr_bucket_get_name_value(inode,
2413                                                                 bucket->xh,
2414                                                                 i,
2415                                                                 &block_off,
2416                                                                 &new_offset);
2417                         if (ret)
2418                                 break;
2419                         size = handler->list(inode, xl->buffer, xl->buffer_size,
2420                                              bucket->bhs[block_off]->b_data +
2421                                              new_offset,
2422                                              entry->xe_name_len);
2423                         if (xl->buffer) {
2424                                 if (size > xl->buffer_size)
2425                                         return -ERANGE;
2426                                 xl->buffer += size;
2427                         }
2428                         xl->buffer_size -= size;
2429                 }
2430         }
2431
2432         return ret;
2433 }
2434
2435 static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
2436                                              struct ocfs2_xattr_tree_root *xt,
2437                                              char *buffer,
2438                                              size_t buffer_size)
2439 {
2440         struct ocfs2_extent_list *el = &xt->xt_list;
2441         int ret = 0;
2442         u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
2443         u64 p_blkno = 0;
2444         struct ocfs2_xattr_tree_list xl = {
2445                 .buffer = buffer,
2446                 .buffer_size = buffer_size,
2447         };
2448
2449         if (le16_to_cpu(el->l_next_free_rec) == 0)
2450                 return 0;
2451
2452         while (name_hash > 0) {
2453                 ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
2454                                           &e_cpos, &num_clusters, el);
2455                 if (ret) {
2456                         mlog_errno(ret);
2457                         goto out;
2458                 }
2459
2460                 ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
2461                                                   ocfs2_list_xattr_bucket,
2462                                                   &xl);
2463                 if (ret) {
2464                         mlog_errno(ret);
2465                         goto out;
2466                 }
2467
2468                 if (e_cpos == 0)
2469                         break;
2470
2471                 name_hash = e_cpos - 1;
2472         }
2473
2474         ret = buffer_size - xl.buffer_size;
2475 out:
2476         return ret;
2477 }