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