[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.suse / ocfs2-Add-xattr-bucket-iteration-for.patch

From: Tao Ma <tao.ma@oracle.com>
Subject: [PATCH 11/16] ocfs2: Add xattr bucket iteration for large numbers of EAs
Patch-mainline: 2.6.28?
References: FATE302067 

Ocfs2 breaks up xattr index tree leaves into 4k regions, called buckets.
Attributes are stored within a given bucket, depending on hash value.

After a discussion with Mark, we decided that the per-bucket index
(xe_entry[]) would only exist in the 1st block of a bucket. Likewise,
name/value pairs will not straddle more than one block. This allows the
majority of operations to work directly on the buffer heads in a leaf block.

This patch adds code to iterate the buckets in an EA. A new abstration of
ocfs2_xattr_bucket is added. It records the bhs in this bucket and
ocfs2_xattr_header. This keeps the code neat, improving readibility.

Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
---
 fs/ocfs2/ocfs2_fs.h |   35 +++++++-
 fs/ocfs2/xattr.c    |  255 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 fs/ocfs2/xattr.h    |    9 ++
 3 files changed, 293 insertions(+), 6 deletions(-)

diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
index 98e1f8b..8d5e72f 100644
--- a/fs/ocfs2/ocfs2_fs.h
+++ b/fs/ocfs2/ocfs2_fs.h
@@ -755,8 +755,13 @@ struct ocfs2_xattr_header {
 	__le16	xh_count;                       /* contains the count of how
 						   many records are in the
 						   local xattr storage. */
-	__le16	xh_reserved1;
-	__le32	xh_reserved2;
+	__le16	xh_free_start;                  /* current offset for storing
+						   xattr. */
+	__le16	xh_name_value_len;              /* total length of name/value
+						   length in this bucket. */
+	__le16	xh_num_buckets;                 /* bucket nums in one extent
+						   record, only valid in the
+						   first bucket. */
 	__le64  xh_csum;
 	struct ocfs2_xattr_entry xh_entries[0]; /* xattr entry list. */
 };
@@ -793,6 +798,10 @@ struct ocfs2_xattr_tree_root {
 #define OCFS2_XATTR_SIZE(size)	(((size) + OCFS2_XATTR_ROUND) & \
 				~(OCFS2_XATTR_ROUND))
 
+#define OCFS2_XATTR_BUCKET_SIZE			4096
+#define OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET 	(OCFS2_XATTR_BUCKET_SIZE \
+						 / OCFS2_MIN_BLOCKSIZE)
+
 /*
  * On disk structure for xattr block.
  */
@@ -963,6 +972,17 @@ static inline u64 ocfs2_backup_super_blkno(struct super_block *sb, int index)
 	return 0;
 
 }
+
+static inline u16 ocfs2_xattr_recs_per_xb(struct super_block *sb)
+{
+	int size;
+
+	size = sb->s_blocksize -
+		offsetof(struct ocfs2_xattr_block,
+			 xb_attrs.xb_root.xt_list.l_recs);
+
+	return size / sizeof(struct ocfs2_extent_rec);
+}
 #else
 static inline int ocfs2_fast_symlink_chars(int blocksize)
 {
@@ -1046,6 +1066,17 @@ static inline uint64_t ocfs2_backup_super_blkno(int blocksize, int index)
 
 	return 0;
 }
+
+static inline int ocfs2_xattr_recs_per_xb(int blocksize)
+{
+	int size;
+
+	size = blocksize -
+		offsetof(struct ocfs2_xattr_block,
+			 xb_attrs.xb_root.xt_list.l_recs);
+
+	return size / sizeof(struct ocfs2_extent_rec);
+}
 #endif  /* __KERNEL__ */
 
 
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 3685cc6..ed41c15 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -52,6 +52,7 @@
 #include "suballoc.h"
 #include "uptodate.h"
 #include "buffer_head_io.h"
+#include "super.h"
 #include "xattr.h"
 
 
@@ -60,6 +61,11 @@ struct ocfs2_xattr_def_value_root {
 	struct ocfs2_extent_rec		er;
 };
 
+struct ocfs2_xattr_bucket {
+	struct buffer_head *bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
+	struct ocfs2_xattr_header *xh;
+};
+
 #define OCFS2_XATTR_ROOT_SIZE	(sizeof(struct ocfs2_xattr_def_value_root))
 #define OCFS2_XATTR_INLINE_SIZE	80
 
@@ -115,6 +121,11 @@ struct ocfs2_xattr_search {
 	int not_found;
 };
 
+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+					struct ocfs2_xattr_tree_root *xt,
+					char *buffer,
+					size_t buffer_size);
+
 static inline struct xattr_handler *ocfs2_xattr_handler(int name_index)
 {
 	struct xattr_handler *handler = NULL;
@@ -499,7 +510,7 @@ static int ocfs2_xattr_block_list(struct inode *inode,
 				  size_t buffer_size)
 {
 	struct buffer_head *blk_bh = NULL;
-	struct ocfs2_xattr_header *header = NULL;
+	struct ocfs2_xattr_block *xb;
 	int ret = 0;
 
 	if (!di->i_xattr_loc)
@@ -519,10 +530,17 @@ static int ocfs2_xattr_block_list(struct inode *inode,
 		goto cleanup;
 	}
 
-	header = &((struct ocfs2_xattr_block *)blk_bh->b_data)->
-		 xb_attrs.xb_header;
+	xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
 
-	ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
+	if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+		struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
+		ret = ocfs2_xattr_list_entries(inode, header,
+					       buffer, buffer_size);
+	} else {
+		struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
+		ret = ocfs2_xattr_tree_list_index_block(inode, xt,
+						   buffer, buffer_size);
+	}
 cleanup:
 	brelse(blk_bh);
 
@@ -1939,3 +1957,232 @@ cleanup:
 	return ret;
 }
 
+/*
+ * Find the xattr extent rec which may contains name_hash.
+ * e_cpos will be the first name hash of the xattr rec.
+ * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
+ */
+static int ocfs2_xattr_get_rec(struct inode *inode,
+			       u32 name_hash,
+			       u64 *p_blkno,
+			       u32 *e_cpos,
+			       u32 *num_clusters,
+			       struct ocfs2_extent_list *el)
+{
+	int ret = 0, i;
+	struct buffer_head *eb_bh = NULL;
+	struct ocfs2_extent_block *eb;
+	struct ocfs2_extent_rec *rec = NULL;
+	u64 e_blkno = 0;
+
+	if (el->l_tree_depth) {
+		ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh);
+		if (ret) {
+			mlog_errno(ret);
+			goto out;
+		}
+
+		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
+		el = &eb->h_list;
+
+		if (el->l_tree_depth) {
+			ocfs2_error(inode->i_sb,
+				    "Inode %lu has non zero tree depth in "
+				    "xattr tree block %llu\n", inode->i_ino,
+				    (unsigned long long)eb_bh->b_blocknr);
+			ret = -EROFS;
+			goto out;
+		}
+	}
+
+	for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
+		rec = &el->l_recs[i];
+
+		if (le32_to_cpu(rec->e_cpos) <= name_hash) {
+			e_blkno = le64_to_cpu(rec->e_blkno);
+			break;
+		}
+	}
+
+	if (!e_blkno) {
+		ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
+			    "record (%u, %u, 0) in xattr", inode->i_ino,
+			    le32_to_cpu(rec->e_cpos),
+			    ocfs2_rec_clusters(el, rec));
+		ret = -EROFS;
+		goto out;
+	}
+
+	*p_blkno = le64_to_cpu(rec->e_blkno);
+	*num_clusters = le16_to_cpu(rec->e_leaf_clusters);
+	if (e_cpos)
+		*e_cpos = le32_to_cpu(rec->e_cpos);
+out:
+	brelse(eb_bh);
+	return ret;
+}
+
+typedef int (xattr_bucket_func)(struct inode *inode,
+				struct ocfs2_xattr_bucket *bucket,
+				void *para);
+
+static int ocfs2_iterate_xattr_buckets(struct inode *inode,
+				       u64 blkno,
+				       u32 clusters,
+				       xattr_bucket_func *func,
+				       void *para)
+{
+	int i, j, ret = 0;
+	int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+	u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
+	u32 num_buckets = clusters * bpc;
+	struct ocfs2_xattr_bucket bucket;
+
+	memset(&bucket, 0, sizeof(bucket));
+
+	mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
+	     clusters, blkno);
+
+	for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
+		ret = ocfs2_read_blocks(OCFS2_SB(inode->i_sb),
+					blkno, blk_per_bucket,
+					bucket.bhs, OCFS2_BH_CACHED, inode);
+		if (ret) {
+			mlog_errno(ret);
+			goto out;
+		}
+
+		bucket.xh = (struct ocfs2_xattr_header *)bucket.bhs[0]->b_data;
+		/*
+		 * The real bucket num in this series of blocks is stored
+		 * in the 1st bucket.
+		 */
+		if (i == 0)
+			num_buckets = le16_to_cpu(bucket.xh->xh_num_buckets);
+
+		mlog(0, "iterating xattr bucket %llu\n", blkno);
+		if (func) {
+			ret = func(inode, &bucket, para);
+			if (ret) {
+				mlog_errno(ret);
+				break;
+			}
+		}
+
+		for (j = 0; j < blk_per_bucket; j++)
+			brelse(bucket.bhs[j]);
+		memset(&bucket, 0, sizeof(bucket));
+	}
+
+out:
+	for (j = 0; j < blk_per_bucket; j++)
+		brelse(bucket.bhs[j]);
+
+	return ret;
+}
+
+struct ocfs2_xattr_tree_list {
+	char *buffer;
+	size_t buffer_size;
+};
+
+static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
+					     struct ocfs2_xattr_header *xh,
+					     int index,
+					     int *block_off,
+					     int *new_offset)
+{
+	u16 name_offset;
+
+	if (index < 0 || index >= le16_to_cpu(xh->xh_count))
+		return -EINVAL;
+
+	name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
+
+	*block_off = name_offset >> inode->i_sb->s_blocksize_bits;
+	*new_offset = name_offset % inode->i_sb->s_blocksize;
+
+	return 0;
+}
+
+static int ocfs2_list_xattr_bucket(struct inode *inode,
+				   struct ocfs2_xattr_bucket *bucket,
+				   void *para)
+{
+	int ret = 0;
+	struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
+	size_t size;
+	int i, block_off, new_offset;
+
+	for (i = 0 ; i < le16_to_cpu(bucket->xh->xh_count); i++) {
+		struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i];
+		struct xattr_handler *handler =
+			ocfs2_xattr_handler(ocfs2_xattr_get_type(entry));
+
+		if (handler) {
+			ret = ocfs2_xattr_bucket_get_name_value(inode,
+								bucket->xh,
+								i,
+								&block_off,
+								&new_offset);
+			if (ret)
+				break;
+			size = handler->list(inode, xl->buffer, xl->buffer_size,
+					     bucket->bhs[block_off]->b_data +
+					     new_offset,
+					     entry->xe_name_len);
+			if (xl->buffer) {
+				if (size > xl->buffer_size)
+					return -ERANGE;
+				xl->buffer += size;
+			}
+			xl->buffer_size -= size;
+		}
+	}
+
+	return ret;
+}
+
+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+					     struct ocfs2_xattr_tree_root *xt,
+					     char *buffer,
+					     size_t buffer_size)
+{
+	struct ocfs2_extent_list *el = &xt->xt_list;
+	int ret = 0;
+	u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
+	u64 p_blkno = 0;
+	struct ocfs2_xattr_tree_list xl = {
+		.buffer = buffer,
+		.buffer_size = buffer_size,
+	};
+
+	if (le16_to_cpu(el->l_next_free_rec) == 0)
+		return 0;
+
+	while (name_hash > 0) {
+		ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
+					  &e_cpos, &num_clusters, el);
+		if (ret) {
+			mlog_errno(ret);
+			goto out;
+		}
+
+		ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
+						  ocfs2_list_xattr_bucket,
+						  &xl);
+		if (ret) {
+			mlog_errno(ret);
+			goto out;
+		}
+
+		if (e_cpos == 0)
+			break;
+
+		name_hash = e_cpos - 1;
+	}
+
+	ret = buffer_size - xl.buffer_size;
+out:
+	return ret;
+}
diff --git a/fs/ocfs2/xattr.h b/fs/ocfs2/xattr.h
index f565c64..a69c8aa 100644
--- a/fs/ocfs2/xattr.h
+++ b/fs/ocfs2/xattr.h
@@ -55,4 +55,13 @@ extern int ocfs2_xattr_set(struct inode *, int, const char *, const void *,
 extern int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh);
 extern struct xattr_handler *ocfs2_xattr_handlers[];
 
+static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
+{
+	return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE;
+}
+
+static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb)
+{
+	return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits);
+}
 #endif /* OCFS2_XATTR_H */
-- 
1.5.4.5
Commit	Line	Data
2cb7cef9 BS	1	From: Tao Ma <tao.ma@oracle.com>
	2	Subject: [PATCH 11/16] ocfs2: Add xattr bucket iteration for large numbers of EAs
	3	Patch-mainline: 2.6.28?
	4	References: FATE302067
	5
	6	Ocfs2 breaks up xattr index tree leaves into 4k regions, called buckets.
	7	Attributes are stored within a given bucket, depending on hash value.
	8
	9	After a discussion with Mark, we decided that the per-bucket index
	10	(xe_entry[]) would only exist in the 1st block of a bucket. Likewise,
	11	name/value pairs will not straddle more than one block. This allows the
	12	majority of operations to work directly on the buffer heads in a leaf block.
	13
	14	This patch adds code to iterate the buckets in an EA. A new abstration of
	15	ocfs2_xattr_bucket is added. It records the bhs in this bucket and
	16	ocfs2_xattr_header. This keeps the code neat, improving readibility.
	17
	18	Signed-off-by: Tao Ma <tao.ma@oracle.com>
	19	Signed-off-by: Mark Fasheh <mfasheh@suse.com>
	20	---
	21	fs/ocfs2/ocfs2_fs.h \| 35 +++++++-
	22	fs/ocfs2/xattr.c \| 255 ++++++++++++++++++++++++++++++++++++++++++++++++++-
	23	fs/ocfs2/xattr.h \| 9 ++
	24	3 files changed, 293 insertions(+), 6 deletions(-)
	25
	26	diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
	27	index 98e1f8b..8d5e72f 100644
	28	--- a/fs/ocfs2/ocfs2_fs.h
	29	+++ b/fs/ocfs2/ocfs2_fs.h
	30	@@ -755,8 +755,13 @@ struct ocfs2_xattr_header {
	31	__le16 xh_count; /* contains the count of how
	32	many records are in the
	33	local xattr storage. */
	34	- __le16 xh_reserved1;
	35	- __le32 xh_reserved2;
	36	+ __le16 xh_free_start; /* current offset for storing
	37	+ xattr. */
	38	+ __le16 xh_name_value_len; /* total length of name/value
	39	+ length in this bucket. */
	40	+ __le16 xh_num_buckets; /* bucket nums in one extent
	41	+ record, only valid in the
	42	+ first bucket. */
	43	__le64 xh_csum;
	44	struct ocfs2_xattr_entry xh_entries[0]; /* xattr entry list. */
	45	};
	46	@@ -793,6 +798,10 @@ struct ocfs2_xattr_tree_root {
	47	#define OCFS2_XATTR_SIZE(size) (((size) + OCFS2_XATTR_ROUND) & \
	48	~(OCFS2_XATTR_ROUND))
	49
	50	+#define OCFS2_XATTR_BUCKET_SIZE 4096
	51	+#define OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET (OCFS2_XATTR_BUCKET_SIZE \
	52	+ / OCFS2_MIN_BLOCKSIZE)
	53	+
	54	/*
	55	* On disk structure for xattr block.
	56	*/
	57	@@ -963,6 +972,17 @@ static inline u64 ocfs2_backup_super_blkno(struct super_block *sb, int index)
	58	return 0;
	59
	60	}
	61	+
	62	+static inline u16 ocfs2_xattr_recs_per_xb(struct super_block *sb)
	63	+{
	64	+ int size;
65	+
66	+ size = sb->s_blocksize -
67	+ offsetof(struct ocfs2_xattr_block,
68	+ xb_attrs.xb_root.xt_list.l_recs);
69	+
70	+ return size / sizeof(struct ocfs2_extent_rec);
71	+}
72	#else
73	static inline int ocfs2_fast_symlink_chars(int blocksize)
74	{
75	@@ -1046,6 +1066,17 @@ static inline uint64_t ocfs2_backup_super_blkno(int blocksize, int index)
76
77	return 0;
78	}
79	+
80	+static inline int ocfs2_xattr_recs_per_xb(int blocksize)
81	+{
82	+ int size;
83	+
84	+ size = blocksize -
85	+ offsetof(struct ocfs2_xattr_block,
86	+ xb_attrs.xb_root.xt_list.l_recs);
87	+
88	+ return size / sizeof(struct ocfs2_extent_rec);
89	+}
90	#endif /* __KERNEL__ */
91
92
93	diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
94	index 3685cc6..ed41c15 100644
95	--- a/fs/ocfs2/xattr.c
96	+++ b/fs/ocfs2/xattr.c
97	@@ -52,6 +52,7 @@
98	#include "suballoc.h"
99	#include "uptodate.h"
100	#include "buffer_head_io.h"
101	+#include "super.h"
102	#include "xattr.h"
103
104
105	@@ -60,6 +61,11 @@ struct ocfs2_xattr_def_value_root {
106	struct ocfs2_extent_rec er;
107	};
108
109	+struct ocfs2_xattr_bucket {
110	+ struct buffer_head *bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
111	+ struct ocfs2_xattr_header *xh;
112	+};
113	+
114	#define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
115	#define OCFS2_XATTR_INLINE_SIZE 80
116
117	@@ -115,6 +121,11 @@ struct ocfs2_xattr_search {
118	int not_found;
119	};
120
121	+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
122	+ struct ocfs2_xattr_tree_root *xt,
123	+ char *buffer,
124	+ size_t buffer_size);
125	+
126	static inline struct xattr_handler *ocfs2_xattr_handler(int name_index)
127	{
128	struct xattr_handler *handler = NULL;
129	@@ -499,7 +510,7 @@ static int ocfs2_xattr_block_list(struct inode *inode,
130	size_t buffer_size)
131	{
132	struct buffer_head *blk_bh = NULL;
133	- struct ocfs2_xattr_header *header = NULL;
134	+ struct ocfs2_xattr_block *xb;
135	int ret = 0;
136
137	if (!di->i_xattr_loc)
138	@@ -519,10 +530,17 @@ static int ocfs2_xattr_block_list(struct inode *inode,
139	goto cleanup;
140	}
141
142	- header = &((struct ocfs2_xattr_block *)blk_bh->b_data)->
143	- xb_attrs.xb_header;
144	+ xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
145
146	- ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
147	+ if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
148	+ struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
149	+ ret = ocfs2_xattr_list_entries(inode, header,
150	+ buffer, buffer_size);
151	+ } else {
152	+ struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
153	+ ret = ocfs2_xattr_tree_list_index_block(inode, xt,
154	+ buffer, buffer_size);
155	+ }
156	cleanup:
157	brelse(blk_bh);
158
159	@@ -1939,3 +1957,232 @@ cleanup:
160	return ret;
161	}
162
163	+/*
164	+ * Find the xattr extent rec which may contains name_hash.
165	+ * e_cpos will be the first name hash of the xattr rec.
166	+ * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
167	+ */
168	+static int ocfs2_xattr_get_rec(struct inode *inode,
169	+ u32 name_hash,
170	+ u64 *p_blkno,
171	+ u32 *e_cpos,
172	+ u32 *num_clusters,
173	+ struct ocfs2_extent_list *el)
174	+{
175	+ int ret = 0, i;
176	+ struct buffer_head *eb_bh = NULL;
177	+ struct ocfs2_extent_block *eb;
178	+ struct ocfs2_extent_rec *rec = NULL;
179	+ u64 e_blkno = 0;
180	+
181	+ if (el->l_tree_depth) {
182	+ ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh);
183	+ if (ret) {
184	+ mlog_errno(ret);
185	+ goto out;
186	+ }
187	+
188	+ eb = (struct ocfs2_extent_block *) eb_bh->b_data;
189	+ el = &eb->h_list;
190	+
191	+ if (el->l_tree_depth) {
192	+ ocfs2_error(inode->i_sb,
193	+ "Inode %lu has non zero tree depth in "
194	+ "xattr tree block %llu\n", inode->i_ino,
195	+ (unsigned long long)eb_bh->b_blocknr);
196	+ ret = -EROFS;
197	+ goto out;
198	+ }
199	+ }
200	+
201	+ for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
202	+ rec = &el->l_recs[i];
203	+
204	+ if (le32_to_cpu(rec->e_cpos) <= name_hash) {
205	+ e_blkno = le64_to_cpu(rec->e_blkno);
206	+ break;
207	+ }
208	+ }
209	+
210	+ if (!e_blkno) {
211	+ ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
212	+ "record (%u, %u, 0) in xattr", inode->i_ino,
213	+ le32_to_cpu(rec->e_cpos),
214	+ ocfs2_rec_clusters(el, rec));
215	+ ret = -EROFS;
216	+ goto out;
217	+ }
218	+
219	+ *p_blkno = le64_to_cpu(rec->e_blkno);
220	+ *num_clusters = le16_to_cpu(rec->e_leaf_clusters);
221	+ if (e_cpos)
222	+ *e_cpos = le32_to_cpu(rec->e_cpos);
223	+out:
224	+ brelse(eb_bh);
225	+ return ret;
226	+}
227	+
228	+typedef int (xattr_bucket_func)(struct inode *inode,
229	+ struct ocfs2_xattr_bucket *bucket,
230	+ void *para);
231	+
232	+static int ocfs2_iterate_xattr_buckets(struct inode *inode,
233	+ u64 blkno,
234	+ u32 clusters,
235	+ xattr_bucket_func *func,
236	+ void *para)
237	+{
238	+ int i, j, ret = 0;
239	+ int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
240	+ u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
241	+ u32 num_buckets = clusters * bpc;
242	+ struct ocfs2_xattr_bucket bucket;
243	+
244	+ memset(&bucket, 0, sizeof(bucket));
245	+
246	+ mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
247	+ clusters, blkno);
248	+
249	+ for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
250	+ ret = ocfs2_read_blocks(OCFS2_SB(inode->i_sb),
251	+ blkno, blk_per_bucket,
252	+ bucket.bhs, OCFS2_BH_CACHED, inode);
253	+ if (ret) {
254	+ mlog_errno(ret);
255	+ goto out;
256	+ }
257	+
258	+ bucket.xh = (struct ocfs2_xattr_header *)bucket.bhs[0]->b_data;
259	+ /*
260	+ * The real bucket num in this series of blocks is stored
261	+ * in the 1st bucket.
262	+ */
263	+ if (i == 0)
264	+ num_buckets = le16_to_cpu(bucket.xh->xh_num_buckets);
265	+
266	+ mlog(0, "iterating xattr bucket %llu\n", blkno);
267	+ if (func) {
268	+ ret = func(inode, &bucket, para);
269	+ if (ret) {
270	+ mlog_errno(ret);
271	+ break;
272	+ }
273	+ }
274	+
275	+ for (j = 0; j < blk_per_bucket; j++)
276	+ brelse(bucket.bhs[j]);
277	+ memset(&bucket, 0, sizeof(bucket));
278	+ }
279	+
280	+out:
281	+ for (j = 0; j < blk_per_bucket; j++)
282	+ brelse(bucket.bhs[j]);
283	+
284	+ return ret;
285	+}
286	+
287	+struct ocfs2_xattr_tree_list {
288	+ char *buffer;
289	+ size_t buffer_size;
290	+};
291	+
292	+static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
293	+ struct ocfs2_xattr_header *xh,
294	+ int index,
295	+ int *block_off,
296	+ int *new_offset)
297	+{
298	+ u16 name_offset;
299	+
300	+ if (index < 0 \|\| index >= le16_to_cpu(xh->xh_count))
301	+ return -EINVAL;
302	+
303	+ name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
304	+
305	+ *block_off = name_offset >> inode->i_sb->s_blocksize_bits;
306	+ *new_offset = name_offset % inode->i_sb->s_blocksize;
307	+
308	+ return 0;
309	+}
310	+
311	+static int ocfs2_list_xattr_bucket(struct inode *inode,
312	+ struct ocfs2_xattr_bucket *bucket,
313	+ void *para)
314	+{
315	+ int ret = 0;
316	+ struct ocfs2_xattr_tree_list xl = (struct ocfs2_xattr_tree_list )para;
317	+ size_t size;
318	+ int i, block_off, new_offset;
319	+
320	+ for (i = 0 ; i < le16_to_cpu(bucket->xh->xh_count); i++) {
321	+ struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i];
322	+ struct xattr_handler *handler =
323	+ ocfs2_xattr_handler(ocfs2_xattr_get_type(entry));
324	+
325	+ if (handler) {
326	+ ret = ocfs2_xattr_bucket_get_name_value(inode,
327	+ bucket->xh,
328	+ i,
329	+ &block_off,
330	+ &new_offset);
331	+ if (ret)
332	+ break;
333	+ size = handler->list(inode, xl->buffer, xl->buffer_size,
334	+ bucket->bhs[block_off]->b_data +
335	+ new_offset,
336	+ entry->xe_name_len);
337	+ if (xl->buffer) {
338	+ if (size > xl->buffer_size)
339	+ return -ERANGE;
340	+ xl->buffer += size;
341	+ }
342	+ xl->buffer_size -= size;
343	+ }
344	+ }
345	+
346	+ return ret;
347	+}
348	+
349	+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
350	+ struct ocfs2_xattr_tree_root *xt,
351	+ char *buffer,
352	+ size_t buffer_size)
353	+{
354	+ struct ocfs2_extent_list *el = &xt->xt_list;
355	+ int ret = 0;
356	+ u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
357	+ u64 p_blkno = 0;
358	+ struct ocfs2_xattr_tree_list xl = {
359	+ .buffer = buffer,
360	+ .buffer_size = buffer_size,
361	+ };
362	+
363	+ if (le16_to_cpu(el->l_next_free_rec) == 0)
364	+ return 0;
365	+
366	+ while (name_hash > 0) {
367	+ ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
368	+ &e_cpos, &num_clusters, el);
369	+ if (ret) {
370	+ mlog_errno(ret);
371	+ goto out;
372	+ }
373	+
374	+ ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
375	+ ocfs2_list_xattr_bucket,
376	+ &xl);
377	+ if (ret) {
378	+ mlog_errno(ret);
379	+ goto out;
380	+ }
381	+
382	+ if (e_cpos == 0)
383	+ break;
384	+
385	+ name_hash = e_cpos - 1;
386	+ }
387	+
388	+ ret = buffer_size - xl.buffer_size;
389	+out:
390	+ return ret;
391	+}
392	diff --git a/fs/ocfs2/xattr.h b/fs/ocfs2/xattr.h
393	index f565c64..a69c8aa 100644
394	--- a/fs/ocfs2/xattr.h
395	+++ b/fs/ocfs2/xattr.h
396	@@ -55,4 +55,13 @@ extern int ocfs2_xattr_set(struct inode , int, const char , const void *,
397	extern int ocfs2_xattr_remove(struct inode inode, struct buffer_head di_bh);
398	extern struct xattr_handler *ocfs2_xattr_handlers[];
399
400	+static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
401	+{
402	+ return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE;
403	+}
404	+
405	+static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb)
406	+{
407	+ return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits);
408	+}
409	#endif /* OCFS2_XATTR_H */
410	--
411	1.5.4.5
412