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