Root/fs/ocfs2/xattr.c

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