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