2008-08-18 03:38:48 -06:00
|
|
|
/* -*- mode: c; c-basic-offset: 8; -*-
|
|
|
|
* vim: noexpandtab sw=8 ts=8 sts=0:
|
|
|
|
*
|
|
|
|
* xattr.c
|
|
|
|
*
|
2008-10-23 02:33:03 -06:00
|
|
|
* Copyright (C) 2004, 2008 Oracle. All rights reserved.
|
2008-08-18 03:38:48 -06:00
|
|
|
*
|
2008-08-18 03:11:00 -06:00
|
|
|
* CREDITS:
|
2008-10-23 02:33:03 -06:00
|
|
|
* Lots of code in this file is copy from linux/fs/ext3/xattr.c.
|
|
|
|
* Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
|
2008-08-18 03:11:00 -06:00
|
|
|
*
|
2008-08-18 03:38:48 -06:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
2008-10-23 02:33:03 -06:00
|
|
|
* License version 2 as published by the Free Software Foundation.
|
2008-08-18 03:38:48 -06:00
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*/
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
#include <linux/capability.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/uio.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/splice.h>
|
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
#include <linux/falloc.h>
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
#include <linux/sort.h>
|
2008-10-07 15:52:59 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/string.h>
|
2008-11-13 20:16:27 -07:00
|
|
|
#include <linux/security.h>
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2008-08-18 03:38:48 -06:00
|
|
|
#define MLOG_MASK_PREFIX ML_XATTR
|
|
|
|
#include <cluster/masklog.h>
|
|
|
|
|
|
|
|
#include "ocfs2.h"
|
|
|
|
#include "alloc.h"
|
2008-10-17 15:55:01 -06:00
|
|
|
#include "blockcheck.h"
|
2008-08-18 03:38:48 -06:00
|
|
|
#include "dlmglue.h"
|
|
|
|
#include "file.h"
|
2008-08-18 03:11:00 -06:00
|
|
|
#include "symlink.h"
|
|
|
|
#include "sysfile.h"
|
2008-08-18 03:38:48 -06:00
|
|
|
#include "inode.h"
|
|
|
|
#include "journal.h"
|
|
|
|
#include "ocfs2_fs.h"
|
|
|
|
#include "suballoc.h"
|
|
|
|
#include "uptodate.h"
|
|
|
|
#include "buffer_head_io.h"
|
2008-08-18 03:38:50 -06:00
|
|
|
#include "super.h"
|
2008-08-18 03:11:00 -06:00
|
|
|
#include "xattr.h"
|
2009-08-17 21:43:17 -06:00
|
|
|
#include "refcounttree.h"
|
2009-08-17 21:47:56 -06:00
|
|
|
#include "acl.h"
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
struct ocfs2_xattr_def_value_root {
|
|
|
|
struct ocfs2_xattr_value_root xv;
|
|
|
|
struct ocfs2_extent_rec er;
|
|
|
|
};
|
|
|
|
|
2008-08-18 03:38:50 -06:00
|
|
|
struct ocfs2_xattr_bucket {
|
2008-10-24 20:13:20 -06:00
|
|
|
/* The inode these xattrs are associated with */
|
|
|
|
struct inode *bu_inode;
|
|
|
|
|
|
|
|
/* The actual buffers that make up the bucket */
|
2008-10-18 20:11:42 -06:00
|
|
|
struct buffer_head *bu_bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
|
2008-10-24 20:13:20 -06:00
|
|
|
|
|
|
|
/* How many blocks make up one bucket for this filesystem */
|
|
|
|
int bu_blocks;
|
2008-08-18 03:38:50 -06:00
|
|
|
};
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt {
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_alloc_context *meta_ac;
|
|
|
|
struct ocfs2_alloc_context *data_ac;
|
|
|
|
struct ocfs2_cached_dealloc_ctxt dealloc;
|
|
|
|
};
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
#define OCFS2_XATTR_ROOT_SIZE (sizeof(struct ocfs2_xattr_def_value_root))
|
|
|
|
#define OCFS2_XATTR_INLINE_SIZE 80
|
2009-02-19 20:11:50 -07:00
|
|
|
#define OCFS2_XATTR_HEADER_GAP 4
|
2008-11-13 20:16:41 -07:00
|
|
|
#define OCFS2_XATTR_FREE_IN_IBODY (OCFS2_MIN_XATTR_INLINE_SIZE \
|
|
|
|
- sizeof(struct ocfs2_xattr_header) \
|
2009-02-19 20:11:50 -07:00
|
|
|
- OCFS2_XATTR_HEADER_GAP)
|
2008-11-13 20:17:41 -07:00
|
|
|
#define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
|
|
|
|
- sizeof(struct ocfs2_xattr_block) \
|
|
|
|
- sizeof(struct ocfs2_xattr_header) \
|
2009-02-19 20:11:50 -07:00
|
|
|
- OCFS2_XATTR_HEADER_GAP)
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
static struct ocfs2_xattr_def_value_root def_xv = {
|
|
|
|
.xv.xr_list.l_count = cpu_to_le16(1),
|
|
|
|
};
|
|
|
|
|
|
|
|
struct xattr_handler *ocfs2_xattr_handlers[] = {
|
|
|
|
&ocfs2_xattr_user_handler,
|
2008-11-13 20:17:04 -07:00
|
|
|
&ocfs2_xattr_acl_access_handler,
|
|
|
|
&ocfs2_xattr_acl_default_handler,
|
2008-08-18 03:11:00 -06:00
|
|
|
&ocfs2_xattr_trusted_handler,
|
2008-11-13 20:16:27 -07:00
|
|
|
&ocfs2_xattr_security_handler,
|
2008-08-18 03:11:00 -06:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2008-10-23 02:34:44 -06:00
|
|
|
static struct xattr_handler *ocfs2_xattr_handler_map[OCFS2_XATTR_MAX] = {
|
2008-08-18 03:11:00 -06:00
|
|
|
[OCFS2_XATTR_INDEX_USER] = &ocfs2_xattr_user_handler,
|
2008-11-13 20:17:04 -07:00
|
|
|
[OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS]
|
|
|
|
= &ocfs2_xattr_acl_access_handler,
|
|
|
|
[OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT]
|
|
|
|
= &ocfs2_xattr_acl_default_handler,
|
2008-08-18 03:11:00 -06:00
|
|
|
[OCFS2_XATTR_INDEX_TRUSTED] = &ocfs2_xattr_trusted_handler,
|
2008-11-13 20:16:27 -07:00
|
|
|
[OCFS2_XATTR_INDEX_SECURITY] = &ocfs2_xattr_security_handler,
|
2008-08-18 03:11:00 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_info {
|
|
|
|
int name_index;
|
|
|
|
const char *name;
|
|
|
|
const void *value;
|
|
|
|
size_t value_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_search {
|
|
|
|
struct buffer_head *inode_bh;
|
|
|
|
/*
|
|
|
|
* xattr_bh point to the block buffer head which has extended attribute
|
|
|
|
* when extended attribute in inode, xattr_bh is equal to inode_bh.
|
|
|
|
*/
|
|
|
|
struct buffer_head *xattr_bh;
|
|
|
|
struct ocfs2_xattr_header *header;
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket;
|
2008-08-18 03:11:00 -06:00
|
|
|
void *base;
|
|
|
|
void *end;
|
|
|
|
struct ocfs2_xattr_entry *here;
|
|
|
|
int not_found;
|
|
|
|
};
|
|
|
|
|
2009-08-17 21:43:21 -06:00
|
|
|
static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
|
2008-08-18 03:38:51 -06:00
|
|
|
struct ocfs2_xattr_header *xh,
|
|
|
|
int index,
|
|
|
|
int *block_off,
|
|
|
|
int *new_offset);
|
|
|
|
|
2008-10-20 19:43:07 -06:00
|
|
|
static int ocfs2_xattr_block_find(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs);
|
2008-08-18 03:38:51 -06:00
|
|
|
static int ocfs2_xattr_index_block_find(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs);
|
|
|
|
|
2008-08-18 03:38:50 -06:00
|
|
|
static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
|
2009-08-17 21:43:42 -06:00
|
|
|
struct buffer_head *blk_bh,
|
2008-08-18 03:38:50 -06:00
|
|
|
char *buffer,
|
|
|
|
size_t buffer_size);
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
static int ocfs2_xattr_create_index_block(struct inode *inode,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
typedef int (xattr_tree_rec_func)(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno, u32 cpos, u32 len, void *para);
|
|
|
|
static int ocfs2_iterate_xattr_index_block(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
xattr_tree_rec_func *rec_func,
|
|
|
|
void *para);
|
|
|
|
static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
void *para);
|
|
|
|
static int ocfs2_rm_xattr_cluster(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno,
|
|
|
|
u32 cpos,
|
|
|
|
u32 len,
|
|
|
|
void *para);
|
|
|
|
|
2008-11-26 14:36:24 -07:00
|
|
|
static int 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);
|
2009-08-17 21:43:17 -06:00
|
|
|
static int 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_need,
|
|
|
|
int *credits);
|
2009-08-17 21:43:59 -06:00
|
|
|
static int 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);
|
2008-08-18 03:38:54 -06:00
|
|
|
|
2008-10-23 02:33:33 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 ocfs2_xattr_max_xe_in_bucket(struct super_block *sb)
|
|
|
|
{
|
|
|
|
u16 len = sb->s_blocksize -
|
|
|
|
offsetof(struct ocfs2_xattr_header, xh_entries);
|
|
|
|
|
|
|
|
return len / sizeof(struct ocfs2_xattr_entry);
|
|
|
|
}
|
|
|
|
|
2008-10-24 17:21:03 -06:00
|
|
|
#define bucket_blkno(_b) ((_b)->bu_bhs[0]->b_blocknr)
|
2008-10-24 17:57:21 -06:00
|
|
|
#define bucket_block(_b, _n) ((_b)->bu_bhs[(_n)]->b_data)
|
2008-10-24 18:04:49 -06:00
|
|
|
#define bucket_xh(_b) ((struct ocfs2_xattr_header *)bucket_block((_b), 0))
|
2008-10-24 17:21:03 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
static struct ocfs2_xattr_bucket *ocfs2_xattr_bucket_new(struct inode *inode)
|
2008-10-24 18:16:48 -06:00
|
|
|
{
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket;
|
|
|
|
int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2008-10-24 18:16:48 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
BUG_ON(blks > OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET);
|
|
|
|
|
|
|
|
bucket = kzalloc(sizeof(struct ocfs2_xattr_bucket), GFP_NOFS);
|
|
|
|
if (bucket) {
|
|
|
|
bucket->bu_inode = inode;
|
|
|
|
bucket->bu_blocks = blks;
|
|
|
|
}
|
|
|
|
|
|
|
|
return bucket;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < bucket->bu_blocks; i++) {
|
2008-10-24 18:16:48 -06:00
|
|
|
brelse(bucket->bu_bhs[i]);
|
|
|
|
bucket->bu_bhs[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)
|
|
|
|
{
|
|
|
|
if (bucket) {
|
|
|
|
ocfs2_xattr_bucket_relse(bucket);
|
|
|
|
bucket->bu_inode = NULL;
|
|
|
|
kfree(bucket);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-24 18:33:40 -06:00
|
|
|
/*
|
|
|
|
* A bucket that has never been written to disk doesn't need to be
|
|
|
|
* read. We just need the buffer_heads. Don't call this for
|
|
|
|
* buckets that are already on disk. ocfs2_read_xattr_bucket() initializes
|
|
|
|
* them fully.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
|
2008-10-24 18:33:40 -06:00
|
|
|
u64 xb_blkno)
|
|
|
|
{
|
|
|
|
int i, rc = 0;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < bucket->bu_blocks; i++) {
|
|
|
|
bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,
|
|
|
|
xb_blkno + i);
|
2008-10-24 18:33:40 -06:00
|
|
|
if (!bucket->bu_bhs[i]) {
|
|
|
|
rc = -EIO;
|
|
|
|
mlog_errno(rc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-02-10 21:00:41 -07:00
|
|
|
if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
|
2008-11-05 17:10:48 -07:00
|
|
|
bucket->bu_bhs[i]))
|
2009-02-10 21:00:41 -07:00
|
|
|
ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),
|
2008-11-05 17:10:48 -07:00
|
|
|
bucket->bu_bhs[i]);
|
2008-10-24 18:33:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rc)
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_relse(bucket);
|
2008-10-24 18:33:40 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the xattr bucket at xb_blkno */
|
2008-10-24 20:13:20 -06:00
|
|
|
static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,
|
2008-10-24 18:33:40 -06:00
|
|
|
u64 xb_blkno)
|
|
|
|
{
|
2008-10-24 20:13:20 -06:00
|
|
|
int rc;
|
2008-10-24 18:33:40 -06:00
|
|
|
|
2009-02-10 21:00:41 -07:00
|
|
|
rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno,
|
2008-11-13 15:49:19 -07:00
|
|
|
bucket->bu_blocks, bucket->bu_bhs, 0,
|
|
|
|
NULL);
|
2008-12-05 12:19:37 -07:00
|
|
|
if (!rc) {
|
2009-02-24 18:40:26 -07:00
|
|
|
spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
|
2008-12-05 12:19:37 -07:00
|
|
|
rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb,
|
|
|
|
bucket->bu_bhs,
|
|
|
|
bucket->bu_blocks,
|
|
|
|
&bucket_xh(bucket)->xh_check);
|
2009-02-24 18:40:26 -07:00
|
|
|
spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
|
2008-12-05 12:19:37 -07:00
|
|
|
if (rc)
|
|
|
|
mlog_errno(rc);
|
|
|
|
}
|
|
|
|
|
2008-10-24 18:33:40 -06:00
|
|
|
if (rc)
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_relse(bucket);
|
2008-10-24 18:33:40 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-10-24 19:47:33 -06:00
|
|
|
static int ocfs2_xattr_bucket_journal_access(handle_t *handle,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
int i, rc = 0;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < bucket->bu_blocks; i++) {
|
2009-02-12 17:41:25 -07:00
|
|
|
rc = ocfs2_journal_access(handle,
|
|
|
|
INODE_CACHE(bucket->bu_inode),
|
2008-10-24 19:47:33 -06:00
|
|
|
bucket->bu_bhs[i], type);
|
|
|
|
if (rc) {
|
|
|
|
mlog_errno(rc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ocfs2_xattr_bucket_journal_dirty(handle_t *handle,
|
|
|
|
struct ocfs2_xattr_bucket *bucket)
|
|
|
|
{
|
2008-10-24 20:13:20 -06:00
|
|
|
int i;
|
2008-10-24 19:47:33 -06:00
|
|
|
|
2009-02-24 18:40:26 -07:00
|
|
|
spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
|
2008-12-05 12:19:37 -07:00
|
|
|
ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,
|
|
|
|
bucket->bu_bhs, bucket->bu_blocks,
|
|
|
|
&bucket_xh(bucket)->xh_check);
|
2009-02-24 18:40:26 -07:00
|
|
|
spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);
|
2008-12-05 12:19:37 -07:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < bucket->bu_blocks; i++)
|
2008-10-24 19:47:33 -06:00
|
|
|
ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);
|
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
static void ocfs2_xattr_bucket_copy_data(struct ocfs2_xattr_bucket *dest,
|
2008-10-24 19:54:43 -06:00
|
|
|
struct ocfs2_xattr_bucket *src)
|
|
|
|
{
|
|
|
|
int i;
|
2008-10-24 20:13:20 -06:00
|
|
|
int blocksize = src->bu_inode->i_sb->s_blocksize;
|
|
|
|
|
|
|
|
BUG_ON(dest->bu_blocks != src->bu_blocks);
|
|
|
|
BUG_ON(dest->bu_inode != src->bu_inode);
|
2008-10-24 19:54:43 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < src->bu_blocks; i++) {
|
2008-10-24 19:54:43 -06:00
|
|
|
memcpy(bucket_block(dest, i), bucket_block(src, i),
|
|
|
|
blocksize);
|
|
|
|
}
|
|
|
|
}
|
2008-10-24 19:47:33 -06:00
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
static int ocfs2_validate_xattr_block(struct super_block *sb,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
2008-10-17 15:55:01 -06:00
|
|
|
int rc;
|
2008-11-13 15:49:18 -07:00
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)bh->b_data;
|
|
|
|
|
|
|
|
mlog(0, "Validating xattr block %llu\n",
|
|
|
|
(unsigned long long)bh->b_blocknr);
|
|
|
|
|
2008-10-17 15:55:01 -06:00
|
|
|
BUG_ON(!buffer_uptodate(bh));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the ecc fails, we return the error but otherwise
|
|
|
|
* leave the filesystem running. We know any error is
|
|
|
|
* local to this block.
|
|
|
|
*/
|
|
|
|
rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &xb->xb_check);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Errors after here are fatal
|
|
|
|
*/
|
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
if (!OCFS2_IS_VALID_XATTR_BLOCK(xb)) {
|
|
|
|
ocfs2_error(sb,
|
|
|
|
"Extended attribute block #%llu has bad "
|
|
|
|
"signature %.*s",
|
|
|
|
(unsigned long long)bh->b_blocknr, 7,
|
|
|
|
xb->xb_signature);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (le64_to_cpu(xb->xb_blkno) != bh->b_blocknr) {
|
|
|
|
ocfs2_error(sb,
|
|
|
|
"Extended attribute block #%llu has an "
|
|
|
|
"invalid xb_blkno of %llu",
|
|
|
|
(unsigned long long)bh->b_blocknr,
|
|
|
|
(unsigned long long)le64_to_cpu(xb->xb_blkno));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (le32_to_cpu(xb->xb_fs_generation) != OCFS2_SB(sb)->fs_generation) {
|
|
|
|
ocfs2_error(sb,
|
|
|
|
"Extended attribute block #%llu has an invalid "
|
|
|
|
"xb_fs_generation of #%u",
|
|
|
|
(unsigned long long)bh->b_blocknr,
|
|
|
|
le32_to_cpu(xb->xb_fs_generation));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_read_xattr_block(struct inode *inode, u64 xb_blkno,
|
|
|
|
struct buffer_head **bh)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct buffer_head *tmp = *bh;
|
|
|
|
|
2009-02-10 21:00:41 -07:00
|
|
|
rc = ocfs2_read_block(INODE_CACHE(inode), xb_blkno, &tmp,
|
2008-11-13 15:49:19 -07:00
|
|
|
ocfs2_validate_xattr_block);
|
2008-11-13 15:49:18 -07:00
|
|
|
|
|
|
|
/* If ocfs2_read_block() got us a new bh, pass it up. */
|
|
|
|
if (!rc && !*bh)
|
|
|
|
*bh = tmp;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
static inline const char *ocfs2_xattr_prefix(int name_index)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
struct xattr_handler *handler = NULL;
|
|
|
|
|
|
|
|
if (name_index > 0 && name_index < OCFS2_XATTR_MAX)
|
|
|
|
handler = ocfs2_xattr_handler_map[name_index];
|
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
return handler ? handler->prefix : NULL;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
2008-10-07 15:31:42 -06:00
|
|
|
static u32 ocfs2_xattr_name_hash(struct inode *inode,
|
2008-10-09 09:06:13 -06:00
|
|
|
const char *name,
|
2008-10-07 15:31:42 -06:00
|
|
|
int name_len)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
/* Get hash value of uuid from super block */
|
|
|
|
u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* hash extended attribute name */
|
|
|
|
for (i = 0; i < name_len; i++) {
|
|
|
|
hash = (hash << OCFS2_HASH_SHIFT) ^
|
|
|
|
(hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
|
|
|
|
*name++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_hash_entry()
|
|
|
|
*
|
|
|
|
* Compute the hash of an extended attribute.
|
|
|
|
*/
|
|
|
|
static void ocfs2_xattr_hash_entry(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_header *header,
|
|
|
|
struct ocfs2_xattr_entry *entry)
|
|
|
|
{
|
|
|
|
u32 hash = 0;
|
|
|
|
char *name = (char *)header + le16_to_cpu(entry->xe_name_offset);
|
|
|
|
|
2008-10-09 09:06:13 -06:00
|
|
|
hash = ocfs2_xattr_name_hash(inode, name, entry->xe_name_len);
|
2008-08-18 03:11:00 -06:00
|
|
|
entry->xe_name_hash = cpu_to_le32(hash);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
2008-08-18 03:38:48 -06:00
|
|
|
|
2008-11-13 20:16:41 -07:00
|
|
|
static int ocfs2_xattr_entry_real_size(int name_len, size_t value_len)
|
|
|
|
{
|
|
|
|
int size = 0;
|
|
|
|
|
|
|
|
if (value_len <= OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(value_len);
|
|
|
|
else
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
size += sizeof(struct ocfs2_xattr_entry);
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
int 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)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
|
|
|
|
int s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
|
|
|
|
si->value_len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The max space of security xattr taken inline is
|
|
|
|
* 256(name) + 80(value) + 16(entry) = 352 bytes,
|
|
|
|
* So reserve one metadata block for it is ok.
|
|
|
|
*/
|
|
|
|
if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
|
|
|
|
s_size > OCFS2_XATTR_FREE_IN_IBODY) {
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(osb, 1, xattr_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
*xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reserve clusters for xattr value which will be set in B tree*/
|
2008-12-09 01:42:51 -07:00
|
|
|
if (si->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
|
|
|
|
si->value_len);
|
|
|
|
|
|
|
|
*xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
|
|
|
|
new_clusters);
|
|
|
|
*want_clusters += new_clusters;
|
|
|
|
}
|
2008-11-13 20:16:41 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:17:41 -07:00
|
|
|
int ocfs2_calc_xattr_init(struct inode *dir,
|
|
|
|
struct buffer_head *dir_bh,
|
|
|
|
int mode,
|
|
|
|
struct ocfs2_security_xattr_info *si,
|
|
|
|
int *want_clusters,
|
|
|
|
int *xattr_credits,
|
2008-11-12 17:27:44 -07:00
|
|
|
int *want_meta)
|
2008-11-13 20:17:41 -07:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
|
2008-12-09 01:42:51 -07:00
|
|
|
int s_size = 0, a_size = 0, acl_len = 0, new_clusters;
|
2008-11-13 20:17:41 -07:00
|
|
|
|
|
|
|
if (si->enable)
|
|
|
|
s_size = ocfs2_xattr_entry_real_size(strlen(si->name),
|
|
|
|
si->value_len);
|
|
|
|
|
|
|
|
if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) {
|
|
|
|
acl_len = ocfs2_xattr_get_nolock(dir, dir_bh,
|
|
|
|
OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
|
|
|
|
"", NULL, 0);
|
|
|
|
if (acl_len > 0) {
|
|
|
|
a_size = ocfs2_xattr_entry_real_size(0, acl_len);
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
a_size <<= 1;
|
|
|
|
} else if (acl_len != 0 && acl_len != -ENODATA) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(s_size + a_size))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The max space of security xattr taken inline is
|
|
|
|
* 256(name) + 80(value) + 16(entry) = 352 bytes,
|
|
|
|
* The max space of acl xattr taken inline is
|
|
|
|
* 80(value) + 16(entry) * 2(if directory) = 192 bytes,
|
|
|
|
* when blocksize = 512, may reserve one more cluser for
|
|
|
|
* xattr bucket, otherwise reserve one metadata block
|
|
|
|
* for them is ok.
|
2009-03-05 19:19:30 -07:00
|
|
|
* If this is a new directory with inline data,
|
|
|
|
* we choose to reserve the entire inline area for
|
|
|
|
* directory contents and force an external xattr block.
|
2008-11-13 20:17:41 -07:00
|
|
|
*/
|
|
|
|
if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE ||
|
2009-03-05 19:19:30 -07:00
|
|
|
(S_ISDIR(mode) && ocfs2_supports_inline_data(osb)) ||
|
2008-11-13 20:17:41 -07:00
|
|
|
(s_size + a_size) > OCFS2_XATTR_FREE_IN_IBODY) {
|
2008-11-12 17:27:44 -07:00
|
|
|
*want_meta = *want_meta + 1;
|
2008-11-13 20:17:41 -07:00
|
|
|
*xattr_credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE &&
|
|
|
|
(s_size + a_size) > OCFS2_XATTR_FREE_IN_BLOCK(dir)) {
|
|
|
|
*want_clusters += 1;
|
|
|
|
*xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb);
|
|
|
|
}
|
|
|
|
|
2008-12-09 01:42:51 -07:00
|
|
|
/*
|
|
|
|
* reserve credits and clusters for xattrs which has large value
|
|
|
|
* and have to be set outside
|
|
|
|
*/
|
|
|
|
if (si->enable && si->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
new_clusters = ocfs2_clusters_for_bytes(dir->i_sb,
|
|
|
|
si->value_len);
|
|
|
|
*xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
|
|
|
|
new_clusters);
|
|
|
|
*want_clusters += new_clusters;
|
|
|
|
}
|
2008-11-13 20:17:41 -07:00
|
|
|
if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL &&
|
|
|
|
acl_len > OCFS2_XATTR_INLINE_SIZE) {
|
2008-12-09 01:42:51 -07:00
|
|
|
/* for directory, it has DEFAULT and ACCESS two types of acls */
|
|
|
|
new_clusters = (S_ISDIR(mode) ? 2 : 1) *
|
|
|
|
ocfs2_clusters_for_bytes(dir->i_sb, acl_len);
|
|
|
|
*xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb,
|
|
|
|
new_clusters);
|
|
|
|
*want_clusters += new_clusters;
|
2008-11-13 20:17:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:38:48 -06:00
|
|
|
static int ocfs2_xattr_extend_allocation(struct inode *inode,
|
|
|
|
u32 clusters_to_add,
|
2008-12-09 15:36:50 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:38:48 -06:00
|
|
|
{
|
|
|
|
int status = 0;
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
2008-08-18 03:38:48 -06:00
|
|
|
enum ocfs2_alloc_restarted why;
|
2008-12-09 15:36:50 -07:00
|
|
|
u32 prev_clusters, logical_start = le32_to_cpu(vb->vb_xv->xr_clusters);
|
2008-08-20 20:36:33 -06:00
|
|
|
struct ocfs2_extent_tree et;
|
2008-08-18 03:38:48 -06:00
|
|
|
|
|
|
|
mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add);
|
|
|
|
|
2009-02-13 04:54:22 -07:00
|
|
|
ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
|
2008-08-20 20:36:33 -06:00
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
status = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
|
2008-12-09 15:24:33 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (status < 0) {
|
|
|
|
mlog_errno(status);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2008-12-09 15:36:50 -07:00
|
|
|
prev_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
|
2009-02-13 04:34:15 -07:00
|
|
|
status = ocfs2_add_clusters_in_btree(handle,
|
|
|
|
&et,
|
2008-08-18 03:38:48 -06:00
|
|
|
&logical_start,
|
|
|
|
clusters_to_add,
|
|
|
|
0,
|
2008-11-11 17:27:00 -07:00
|
|
|
ctxt->data_ac,
|
|
|
|
ctxt->meta_ac,
|
2008-08-20 20:36:33 -06:00
|
|
|
&why);
|
2008-11-11 17:27:01 -07:00
|
|
|
if (status < 0) {
|
|
|
|
mlog_errno(status);
|
2008-08-18 03:38:48 -06:00
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2008-12-09 15:36:50 -07:00
|
|
|
status = ocfs2_journal_dirty(handle, vb->vb_bh);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (status < 0) {
|
|
|
|
mlog_errno(status);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2008-12-09 15:36:50 -07:00
|
|
|
clusters_to_add -= le32_to_cpu(vb->vb_xv->xr_clusters) - prev_clusters;
|
2008-08-18 03:38:48 -06:00
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
/*
|
|
|
|
* We should have already allocated enough space before the transaction,
|
|
|
|
* so no need to restart.
|
|
|
|
*/
|
|
|
|
BUG_ON(why != RESTART_NONE || clusters_to_add);
|
2008-08-18 03:38:48 -06:00
|
|
|
|
|
|
|
leave:
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __ocfs2_remove_xattr_range(struct inode *inode,
|
2008-12-09 15:30:41 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-08-18 03:38:48 -06:00
|
|
|
u32 cpos, u32 phys_cpos, u32 len,
|
2009-08-17 21:43:17 -06:00
|
|
|
unsigned int ext_flags,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:38:48 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
2008-08-20 20:36:33 -06:00
|
|
|
struct ocfs2_extent_tree et;
|
|
|
|
|
2009-02-13 04:54:22 -07:00
|
|
|
ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
|
2008-08-18 03:38:48 -06:00
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
|
2008-12-09 15:30:41 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:38:48 -06:00
|
|
|
}
|
|
|
|
|
2009-02-13 04:41:26 -07:00
|
|
|
ret = ocfs2_remove_extent(handle, &et, cpos, len, ctxt->meta_ac,
|
2008-11-11 17:27:00 -07:00
|
|
|
&ctxt->dealloc);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:38:48 -06:00
|
|
|
}
|
|
|
|
|
2008-12-09 15:30:41 -07:00
|
|
|
le32_add_cpu(&vb->vb_xv->xr_clusters, -len);
|
2008-08-18 03:38:48 -06:00
|
|
|
|
2008-12-09 15:30:41 -07:00
|
|
|
ret = ocfs2_journal_dirty(handle, vb->vb_bh);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:38:48 -06:00
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
if (ext_flags & OCFS2_EXT_REFCOUNTED)
|
|
|
|
ret = ocfs2_decrease_refcount(inode, handle,
|
|
|
|
ocfs2_blocks_to_clusters(inode->i_sb,
|
|
|
|
phys_blkno),
|
|
|
|
len, ctxt->meta_ac, &ctxt->dealloc, 1);
|
|
|
|
else
|
|
|
|
ret = ocfs2_cache_cluster_dealloc(&ctxt->dealloc,
|
|
|
|
phys_blkno, len);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_shrink_size(struct inode *inode,
|
|
|
|
u32 old_clusters,
|
|
|
|
u32 new_clusters,
|
2008-12-09 15:36:50 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:38:48 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2009-08-17 21:43:17 -06:00
|
|
|
unsigned int ext_flags;
|
2008-08-18 03:38:48 -06:00
|
|
|
u32 trunc_len, cpos, phys_cpos, alloc_size;
|
|
|
|
u64 block;
|
|
|
|
|
|
|
|
if (old_clusters <= new_clusters)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpos = new_clusters;
|
|
|
|
trunc_len = old_clusters - new_clusters;
|
|
|
|
while (trunc_len) {
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
|
2008-12-09 15:30:41 -07:00
|
|
|
&alloc_size,
|
2009-08-17 21:43:17 -06:00
|
|
|
&vb->vb_xv->xr_list, &ext_flags);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (alloc_size > trunc_len)
|
|
|
|
alloc_size = trunc_len;
|
|
|
|
|
2008-12-09 15:36:50 -07:00
|
|
|
ret = __ocfs2_remove_xattr_range(inode, vb, cpos,
|
2008-08-18 03:38:48 -06:00
|
|
|
phys_cpos, alloc_size,
|
2009-08-17 21:43:17 -06:00
|
|
|
ext_flags, ctxt);
|
2008-08-18 03:38:48 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
|
2009-02-10 21:00:41 -07:00
|
|
|
ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode),
|
|
|
|
block, alloc_size);
|
2008-08-18 03:38:48 -06:00
|
|
|
cpos += alloc_size;
|
|
|
|
trunc_len -= alloc_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_value_truncate(struct inode *inode,
|
2008-12-09 16:01:04 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-11-11 17:27:00 -07:00
|
|
|
int len,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:38:48 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
|
2008-12-09 16:01:04 -07:00
|
|
|
u32 old_clusters = le32_to_cpu(vb->vb_xv->xr_clusters);
|
2008-08-18 03:38:48 -06:00
|
|
|
|
|
|
|
if (new_clusters == old_clusters)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (new_clusters > old_clusters)
|
|
|
|
ret = ocfs2_xattr_extend_allocation(inode,
|
|
|
|
new_clusters - old_clusters,
|
2008-12-09 16:01:04 -07:00
|
|
|
vb, ctxt);
|
2008-08-18 03:38:48 -06:00
|
|
|
else
|
|
|
|
ret = ocfs2_xattr_shrink_size(inode,
|
|
|
|
old_clusters, new_clusters,
|
2008-12-09 16:01:04 -07:00
|
|
|
vb, ctxt);
|
2008-08-18 03:38:48 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
static int ocfs2_xattr_list_entry(char *buffer, size_t size,
|
|
|
|
size_t *result, const char *prefix,
|
|
|
|
const char *name, int name_len)
|
|
|
|
{
|
|
|
|
char *p = buffer + *result;
|
|
|
|
int prefix_len = strlen(prefix);
|
|
|
|
int total_len = prefix_len + name_len + 1;
|
|
|
|
|
|
|
|
*result += total_len;
|
|
|
|
|
|
|
|
/* we are just looking for how big our buffer needs to be */
|
|
|
|
if (!size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (*result > size)
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
memcpy(p, prefix, prefix_len);
|
|
|
|
memcpy(p + prefix_len, name, name_len);
|
|
|
|
p[prefix_len + name_len] = '\0';
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
static int ocfs2_xattr_list_entries(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_header *header,
|
|
|
|
char *buffer, size_t buffer_size)
|
|
|
|
{
|
2008-10-09 09:06:14 -06:00
|
|
|
size_t result = 0;
|
|
|
|
int i, type, ret;
|
|
|
|
const char *prefix, *name;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) {
|
|
|
|
struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
|
2008-10-09 09:06:14 -06:00
|
|
|
type = ocfs2_xattr_get_type(entry);
|
|
|
|
prefix = ocfs2_xattr_prefix(type);
|
|
|
|
|
|
|
|
if (prefix) {
|
|
|
|
name = (const char *)header +
|
|
|
|
le16_to_cpu(entry->xe_name_offset);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_list_entry(buffer, buffer_size,
|
|
|
|
&result, prefix, name,
|
|
|
|
entry->xe_name_len);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
return result;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:49 -06:00
|
|
|
int ocfs2_has_inline_xattr_value_outside(struct inode *inode,
|
|
|
|
struct ocfs2_dinode *di)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_header *xh;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
xh = (struct ocfs2_xattr_header *)
|
|
|
|
((void *)di + inode->i_sb->s_blocksize -
|
|
|
|
le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++)
|
|
|
|
if (!ocfs2_xattr_is_local(&xh->xh_entries[i]))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
static int ocfs2_xattr_ibody_list(struct inode *inode,
|
|
|
|
struct ocfs2_dinode *di,
|
|
|
|
char *buffer,
|
|
|
|
size_t buffer_size)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_header *header = NULL;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
header = (struct ocfs2_xattr_header *)
|
|
|
|
((void *)di + inode->i_sb->s_blocksize -
|
|
|
|
le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_block_list(struct inode *inode,
|
|
|
|
struct ocfs2_dinode *di,
|
|
|
|
char *buffer,
|
|
|
|
size_t buffer_size)
|
|
|
|
{
|
|
|
|
struct buffer_head *blk_bh = NULL;
|
2008-08-18 03:38:50 -06:00
|
|
|
struct ocfs2_xattr_block *xb;
|
2008-08-18 03:11:00 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!di->i_xattr_loc)
|
|
|
|
return ret;
|
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
|
|
|
|
&blk_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:38:50 -06:00
|
|
|
xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
|
|
|
|
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);
|
2009-08-17 21:43:42 -06:00
|
|
|
} else
|
|
|
|
ret = ocfs2_xattr_tree_list_index_block(inode, blk_bh,
|
2008-08-18 03:38:50 -06:00
|
|
|
buffer, buffer_size);
|
2008-11-13 15:49:18 -07:00
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
brelse(blk_bh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t ocfs2_listxattr(struct dentry *dentry,
|
|
|
|
char *buffer,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
int ret = 0, i_ret = 0, b_ret = 0;
|
|
|
|
struct buffer_head *di_bh = NULL;
|
|
|
|
struct ocfs2_dinode *di = NULL;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode);
|
|
|
|
|
2008-08-18 03:11:46 -06:00
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
di = (struct ocfs2_dinode *)di_bh->b_data;
|
|
|
|
|
|
|
|
down_read(&oi->ip_xattr_sem);
|
|
|
|
i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size);
|
|
|
|
if (i_ret < 0)
|
|
|
|
b_ret = 0;
|
|
|
|
else {
|
|
|
|
if (buffer) {
|
|
|
|
buffer += i_ret;
|
|
|
|
size -= i_ret;
|
|
|
|
}
|
|
|
|
b_ret = ocfs2_xattr_block_list(dentry->d_inode, di,
|
|
|
|
buffer, size);
|
|
|
|
if (b_ret < 0)
|
|
|
|
i_ret = 0;
|
|
|
|
}
|
|
|
|
up_read(&oi->ip_xattr_sem);
|
|
|
|
ocfs2_inode_unlock(dentry->d_inode, 0);
|
|
|
|
|
|
|
|
brelse(di_bh);
|
|
|
|
|
|
|
|
return i_ret + b_ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_find_entry(int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *entry;
|
|
|
|
size_t name_len;
|
|
|
|
int i, cmp = 1;
|
|
|
|
|
|
|
|
if (name == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
name_len = strlen(name);
|
|
|
|
entry = xs->here;
|
|
|
|
for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
|
|
|
|
cmp = name_index - ocfs2_xattr_get_type(entry);
|
|
|
|
if (!cmp)
|
|
|
|
cmp = name_len - entry->xe_name_len;
|
|
|
|
if (!cmp)
|
|
|
|
cmp = memcmp(name, (xs->base +
|
|
|
|
le16_to_cpu(entry->xe_name_offset)),
|
|
|
|
name_len);
|
|
|
|
if (cmp == 0)
|
|
|
|
break;
|
|
|
|
entry += 1;
|
|
|
|
}
|
|
|
|
xs->here = entry;
|
|
|
|
|
|
|
|
return cmp ? -ENODATA : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_get_value_outside(struct inode *inode,
|
2008-08-18 03:38:51 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv,
|
2008-08-18 03:11:00 -06:00
|
|
|
void *buffer,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
u32 cpos, p_cluster, num_clusters, bpc, clusters;
|
|
|
|
u64 blkno;
|
|
|
|
int i, ret = 0;
|
|
|
|
size_t cplen, blocksize;
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct ocfs2_extent_list *el;
|
|
|
|
|
|
|
|
el = &xv->xr_list;
|
|
|
|
clusters = le32_to_cpu(xv->xr_clusters);
|
|
|
|
bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
|
|
|
|
blocksize = inode->i_sb->s_blocksize;
|
|
|
|
|
|
|
|
cpos = 0;
|
|
|
|
while (cpos < clusters) {
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
|
2009-08-17 21:41:57 -06:00
|
|
|
&num_clusters, el, NULL);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
|
|
|
|
/* Copy ocfs2_xattr_value */
|
|
|
|
for (i = 0; i < num_clusters * bpc; i++, blkno++) {
|
2009-02-10 21:00:41 -07:00
|
|
|
ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
|
|
|
|
&bh, NULL);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cplen = len >= blocksize ? blocksize : len;
|
|
|
|
memcpy(buffer, bh->b_data, cplen);
|
|
|
|
len -= cplen;
|
|
|
|
buffer += cplen;
|
|
|
|
|
|
|
|
brelse(bh);
|
|
|
|
bh = NULL;
|
|
|
|
if (len == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cpos += num_clusters;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_ibody_get(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
void *buffer,
|
|
|
|
size_t buffer_size,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
|
2008-08-18 03:38:51 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv;
|
2008-08-18 03:11:00 -06:00
|
|
|
size_t size;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
xs->end = (void *)di + inode->i_sb->s_blocksize;
|
|
|
|
xs->header = (struct ocfs2_xattr_header *)
|
|
|
|
(xs->end - le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
xs->base = (void *)xs->header;
|
|
|
|
xs->here = xs->header->xh_entries;
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_find_entry(name_index, name, xs);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
size = le64_to_cpu(xs->here->xe_value_size);
|
|
|
|
if (buffer) {
|
|
|
|
if (size > buffer_size)
|
|
|
|
return -ERANGE;
|
|
|
|
if (ocfs2_xattr_is_local(xs->here)) {
|
|
|
|
memcpy(buffer, (void *)xs->base +
|
|
|
|
le16_to_cpu(xs->here->xe_name_offset) +
|
|
|
|
OCFS2_XATTR_SIZE(xs->here->xe_name_len), size);
|
|
|
|
} else {
|
2008-08-18 03:38:51 -06:00
|
|
|
xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(xs->base + le16_to_cpu(
|
|
|
|
xs->here->xe_name_offset) +
|
|
|
|
OCFS2_XATTR_SIZE(xs->here->xe_name_len));
|
|
|
|
ret = ocfs2_xattr_get_value_outside(inode, xv,
|
2008-08-18 03:11:00 -06:00
|
|
|
buffer, size);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_block_get(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
void *buffer,
|
|
|
|
size_t buffer_size,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_block *xb;
|
2008-08-18 03:38:51 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv;
|
2008-08-18 03:11:00 -06:00
|
|
|
size_t size;
|
2009-07-13 13:49:31 -06:00
|
|
|
int ret = -ENODATA, name_offset, name_len, i;
|
|
|
|
int uninitialized_var(block_off);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!xs->bucket) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-08-18 03:38:51 -06:00
|
|
|
|
2008-10-20 19:43:07 -06:00
|
|
|
ret = ocfs2_xattr_block_find(inode, name_index, name, xs);
|
|
|
|
if (ret) {
|
2008-08-18 03:11:00 -06:00
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2008-11-02 04:04:21 -07:00
|
|
|
if (xs->not_found) {
|
|
|
|
ret = -ENODATA;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2008-10-20 19:43:07 -06:00
|
|
|
xb = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
|
2008-08-18 03:11:00 -06:00
|
|
|
size = le64_to_cpu(xs->here->xe_value_size);
|
|
|
|
if (buffer) {
|
|
|
|
ret = -ERANGE;
|
|
|
|
if (size > buffer_size)
|
|
|
|
goto cleanup;
|
2008-08-18 03:38:51 -06:00
|
|
|
|
|
|
|
name_offset = le16_to_cpu(xs->here->xe_name_offset);
|
|
|
|
name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len);
|
|
|
|
i = xs->here - xs->header->xh_entries;
|
|
|
|
|
|
|
|
if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
|
2008-10-24 20:13:20 -06:00
|
|
|
bucket_xh(xs->bucket),
|
2008-08-18 03:38:51 -06:00
|
|
|
i,
|
|
|
|
&block_off,
|
|
|
|
&name_offset);
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->base = bucket_block(xs->bucket, block_off);
|
2008-08-18 03:38:51 -06:00
|
|
|
}
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ocfs2_xattr_is_local(xs->here)) {
|
|
|
|
memcpy(buffer, (void *)xs->base +
|
2008-08-18 03:38:51 -06:00
|
|
|
name_offset + name_len, size);
|
2008-08-18 03:11:00 -06:00
|
|
|
} else {
|
2008-08-18 03:38:51 -06:00
|
|
|
xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(xs->base + name_offset + name_len);
|
|
|
|
ret = ocfs2_xattr_get_value_outside(inode, xv,
|
2008-08-18 03:11:00 -06:00
|
|
|
buffer, size);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = size;
|
|
|
|
cleanup:
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_free(xs->bucket);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2008-10-20 19:43:07 -06:00
|
|
|
brelse(xs->xattr_bh);
|
|
|
|
xs->xattr_bh = NULL;
|
2008-08-18 03:11:00 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:16:53 -07:00
|
|
|
int ocfs2_xattr_get_nolock(struct inode *inode,
|
|
|
|
struct buffer_head *di_bh,
|
2008-10-23 02:33:33 -06:00
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
void *buffer,
|
|
|
|
size_t buffer_size)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_dinode *di = NULL;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_xattr_search xis = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
struct ocfs2_xattr_search xbs = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
|
2008-08-18 03:11:46 -06:00
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
|
|
|
|
ret = -ENODATA;
|
|
|
|
|
|
|
|
xis.inode_bh = xbs.inode_bh = di_bh;
|
|
|
|
di = (struct ocfs2_dinode *)di_bh->b_data;
|
|
|
|
|
|
|
|
down_read(&oi->ip_xattr_sem);
|
|
|
|
ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer,
|
|
|
|
buffer_size, &xis);
|
2008-11-02 04:04:21 -07:00
|
|
|
if (ret == -ENODATA && di->i_xattr_loc)
|
2008-08-18 03:11:00 -06:00
|
|
|
ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
|
|
|
|
buffer_size, &xbs);
|
|
|
|
up_read(&oi->ip_xattr_sem);
|
2008-11-13 20:16:53 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ocfs2_xattr_get()
|
|
|
|
*
|
|
|
|
* Copy an extended attribute into the buffer provided.
|
|
|
|
* Buffer is NULL to compute the size of buffer required.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_get(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
void *buffer,
|
|
|
|
size_t buffer_size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct buffer_head *di_bh = NULL;
|
|
|
|
|
|
|
|
ret = ocfs2_inode_lock(inode, &di_bh, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index,
|
|
|
|
name, buffer, buffer_size);
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
ocfs2_inode_unlock(inode, 0);
|
|
|
|
|
|
|
|
brelse(di_bh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __ocfs2_xattr_set_value_outside(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
2009-08-17 21:43:17 -06:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-08-18 03:11:00 -06:00
|
|
|
const void *value,
|
|
|
|
int value_len)
|
|
|
|
{
|
2008-12-04 15:20:54 -07:00
|
|
|
int ret = 0, i, cp_len;
|
2008-08-18 03:11:00 -06:00
|
|
|
u16 blocksize = inode->i_sb->s_blocksize;
|
|
|
|
u32 p_cluster, num_clusters;
|
|
|
|
u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
|
|
|
|
u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
|
|
|
|
u64 blkno;
|
|
|
|
struct buffer_head *bh = NULL;
|
2009-08-17 21:43:17 -06:00
|
|
|
unsigned int ext_flags;
|
|
|
|
struct ocfs2_xattr_value_root *xv = vb->vb_xv;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
|
|
|
|
|
|
|
|
while (cpos < clusters) {
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
|
2009-08-17 21:41:57 -06:00
|
|
|
&num_clusters, &xv->xr_list,
|
2009-08-17 21:43:17 -06:00
|
|
|
&ext_flags);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
|
|
|
|
|
|
|
|
for (i = 0; i < num_clusters * bpc; i++, blkno++) {
|
2009-02-10 21:00:41 -07:00
|
|
|
ret = ocfs2_read_block(INODE_CACHE(inode), blkno,
|
|
|
|
&bh, NULL);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_journal_access(handle,
|
2009-02-12 17:41:25 -07:00
|
|
|
INODE_CACHE(inode),
|
2008-08-18 03:11:00 -06:00
|
|
|
bh,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
cp_len = value_len > blocksize ? blocksize : value_len;
|
|
|
|
memcpy(bh->b_data, value, cp_len);
|
|
|
|
value_len -= cp_len;
|
|
|
|
value += cp_len;
|
|
|
|
if (cp_len < blocksize)
|
|
|
|
memset(bh->b_data + cp_len, 0,
|
|
|
|
blocksize - cp_len);
|
|
|
|
|
|
|
|
ret = ocfs2_journal_dirty(handle, bh);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
brelse(bh);
|
|
|
|
bh = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: do we need to empty all the following
|
|
|
|
* blocks in this cluster?
|
|
|
|
*/
|
|
|
|
if (!value_len)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cpos += num_clusters;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
brelse(bh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_cleanup(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
2008-08-18 03:11:00 -06:00
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
2008-12-09 16:58:35 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-08-18 03:11:00 -06:00
|
|
|
size_t offs)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
size_t name_len = strlen(xi->name);
|
|
|
|
void *val = xs->base + offs;
|
|
|
|
size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
|
2008-12-09 16:58:35 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
/* Decrease xattr count */
|
|
|
|
le16_add_cpu(&xs->header->xh_count, -1);
|
|
|
|
/* Remove the xattr entry and tree root which has already be set*/
|
|
|
|
memset((void *)xs->here, 0, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
memset(val, 0, size);
|
|
|
|
|
2008-12-09 16:58:35 -07:00
|
|
|
ret = ocfs2_journal_dirty(handle, vb->vb_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_update_entry(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
2008-08-18 03:11:00 -06:00
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
2008-12-09 16:46:15 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-08-18 03:11:00 -06:00
|
|
|
size_t offs)
|
|
|
|
{
|
2008-11-11 17:27:01 -07:00
|
|
|
int ret;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = vb->vb_access(handle, INODE_CACHE(inode), vb->vb_bh,
|
2008-12-09 16:46:15 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xs->here->xe_name_offset = cpu_to_le16(offs);
|
|
|
|
xs->here->xe_value_size = cpu_to_le64(xi->value_len);
|
|
|
|
if (xi->value_len <= OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
ocfs2_xattr_set_local(xs->here, 1);
|
|
|
|
else
|
|
|
|
ocfs2_xattr_set_local(xs->here, 0);
|
|
|
|
ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
|
|
|
|
|
2008-12-09 16:46:15 -07:00
|
|
|
ret = ocfs2_journal_dirty(handle, vb->vb_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_set_value_outside()
|
|
|
|
*
|
|
|
|
* Set large size value in B tree.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_set_value_outside(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt,
|
2008-12-09 16:58:35 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2008-08-18 03:11:00 -06:00
|
|
|
size_t offs)
|
|
|
|
{
|
|
|
|
size_t name_len = strlen(xi->name);
|
|
|
|
void *val = xs->base + offs;
|
|
|
|
struct ocfs2_xattr_value_root *xv = NULL;
|
|
|
|
size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
memset(val, 0, size);
|
|
|
|
memcpy(val, xi->name, name_len);
|
|
|
|
xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(val + OCFS2_XATTR_SIZE(name_len));
|
|
|
|
xv->xr_clusters = 0;
|
|
|
|
xv->xr_last_eb_blk = 0;
|
|
|
|
xv->xr_list.l_tree_depth = 0;
|
|
|
|
xv->xr_list.l_count = cpu_to_le16(1);
|
|
|
|
xv->xr_list.l_next_free_rec = 0;
|
2008-12-09 16:58:35 -07:00
|
|
|
vb->vb_xv = xv;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2008-12-09 16:58:35 -07:00
|
|
|
ret = ocfs2_xattr_value_truncate(inode, vb, xi->value_len, ctxt);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-12-09 16:58:35 -07:00
|
|
|
ret = ocfs2_xattr_update_entry(inode, ctxt->handle, xi, xs, vb, offs);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-17 21:43:17 -06:00
|
|
|
ret = __ocfs2_xattr_set_value_outside(inode, ctxt->handle, vb,
|
2008-11-11 17:27:01 -07:00
|
|
|
xi->value, xi->value_len);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_set_entry_local()
|
|
|
|
*
|
|
|
|
* Set, replace or remove extended attribute in local.
|
|
|
|
*/
|
|
|
|
static void ocfs2_xattr_set_entry_local(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_entry *last,
|
|
|
|
size_t min_offs)
|
|
|
|
{
|
|
|
|
size_t name_len = strlen(xi->name);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (xi->value && xs->not_found) {
|
|
|
|
/* Insert the new xattr entry. */
|
|
|
|
le16_add_cpu(&xs->header->xh_count, 1);
|
|
|
|
ocfs2_xattr_set_type(last, xi->name_index);
|
|
|
|
ocfs2_xattr_set_local(last, 1);
|
|
|
|
last->xe_name_len = name_len;
|
|
|
|
} else {
|
|
|
|
void *first_val;
|
|
|
|
void *val;
|
|
|
|
size_t offs, size;
|
|
|
|
|
|
|
|
first_val = xs->base + min_offs;
|
|
|
|
offs = le16_to_cpu(xs->here->xe_name_offset);
|
|
|
|
val = xs->base + offs;
|
|
|
|
|
|
|
|
if (le64_to_cpu(xs->here->xe_value_size) >
|
|
|
|
OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
else
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
|
|
|
|
|
|
|
|
if (xi->value && size == OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(xi->value_len)) {
|
|
|
|
/* The old and the new value have the
|
|
|
|
same size. Just replace the value. */
|
|
|
|
ocfs2_xattr_set_local(xs->here, 1);
|
|
|
|
xs->here->xe_value_size = cpu_to_le64(xi->value_len);
|
|
|
|
/* Clear value bytes. */
|
|
|
|
memset(val + OCFS2_XATTR_SIZE(name_len),
|
|
|
|
0,
|
|
|
|
OCFS2_XATTR_SIZE(xi->value_len));
|
|
|
|
memcpy(val + OCFS2_XATTR_SIZE(name_len),
|
|
|
|
xi->value,
|
|
|
|
xi->value_len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Remove the old name+value. */
|
|
|
|
memmove(first_val + size, first_val, val - first_val);
|
|
|
|
memset(first_val, 0, size);
|
|
|
|
xs->here->xe_name_hash = 0;
|
|
|
|
xs->here->xe_name_offset = 0;
|
|
|
|
ocfs2_xattr_set_local(xs->here, 1);
|
|
|
|
xs->here->xe_value_size = 0;
|
|
|
|
|
|
|
|
min_offs += size;
|
|
|
|
|
|
|
|
/* Adjust all value offsets. */
|
|
|
|
last = xs->header->xh_entries;
|
|
|
|
for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
|
|
|
|
size_t o = le16_to_cpu(last->xe_name_offset);
|
|
|
|
|
|
|
|
if (o < offs)
|
|
|
|
last->xe_name_offset = cpu_to_le16(o + size);
|
|
|
|
last += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xi->value) {
|
|
|
|
/* Remove the old entry. */
|
|
|
|
last -= 1;
|
|
|
|
memmove(xs->here, xs->here + 1,
|
|
|
|
(void *)last - (void *)xs->here);
|
|
|
|
memset(last, 0, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
le16_add_cpu(&xs->header->xh_count, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (xi->value) {
|
|
|
|
/* Insert the new name+value. */
|
|
|
|
size_t size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(xi->value_len);
|
|
|
|
void *val = xs->base + min_offs - size;
|
|
|
|
|
|
|
|
xs->here->xe_name_offset = cpu_to_le16(min_offs - size);
|
|
|
|
memset(val, 0, size);
|
|
|
|
memcpy(val, xi->name, name_len);
|
|
|
|
memcpy(val + OCFS2_XATTR_SIZE(name_len),
|
|
|
|
xi->value,
|
|
|
|
xi->value_len);
|
|
|
|
xs->here->xe_value_size = cpu_to_le64(xi->value_len);
|
|
|
|
ocfs2_xattr_set_local(xs->here, 1);
|
|
|
|
ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_set_entry()
|
|
|
|
*
|
|
|
|
* Set extended attribute entry into inode or block.
|
|
|
|
*
|
|
|
|
* If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
|
|
|
|
* We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
|
|
|
|
* then set value in B tree with set_value_outside().
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_set_entry(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt,
|
2008-08-18 03:11:00 -06:00
|
|
|
int flag)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *last;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
|
|
|
|
size_t min_offs = xs->end - xs->base, name_len = strlen(xi->name);
|
|
|
|
size_t size_l = 0;
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
2008-08-18 03:11:00 -06:00
|
|
|
int free, i, ret;
|
|
|
|
struct ocfs2_xattr_info xi_l = {
|
|
|
|
.name_index = xi->name_index,
|
|
|
|
.name = xi->name,
|
|
|
|
.value = xi->value,
|
|
|
|
.value_len = xi->value_len,
|
|
|
|
};
|
2008-12-09 16:58:35 -07:00
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = xs->xattr_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_di,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!(flag & OCFS2_INLINE_XATTR_FL)) {
|
|
|
|
BUG_ON(xs->xattr_bh == xs->inode_bh);
|
|
|
|
vb.vb_access = ocfs2_journal_access_xb;
|
|
|
|
} else
|
|
|
|
BUG_ON(xs->xattr_bh != xs->inode_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
/* Compute min_offs, last and free space. */
|
|
|
|
last = xs->header->xh_entries;
|
|
|
|
|
|
|
|
for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
|
|
|
|
size_t offs = le16_to_cpu(last->xe_name_offset);
|
|
|
|
if (offs < min_offs)
|
|
|
|
min_offs = offs;
|
|
|
|
last += 1;
|
|
|
|
}
|
|
|
|
|
2009-02-19 20:11:50 -07:00
|
|
|
free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
|
2008-08-18 03:11:00 -06:00
|
|
|
if (free < 0)
|
2008-10-20 19:24:03 -06:00
|
|
|
return -EIO;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
if (!xs->not_found) {
|
|
|
|
size_t size = 0;
|
|
|
|
if (ocfs2_xattr_is_local(xs->here))
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
|
|
|
|
else
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
free += (size + sizeof(struct ocfs2_xattr_entry));
|
|
|
|
}
|
|
|
|
/* Check free space in inode or block */
|
|
|
|
if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
if (free < sizeof(struct ocfs2_xattr_entry) +
|
|
|
|
OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_ROOT_SIZE) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
size_l = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
xi_l.value = (void *)&def_xv;
|
|
|
|
xi_l.value_len = OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
} else if (xi->value) {
|
|
|
|
if (free < sizeof(struct ocfs2_xattr_entry) +
|
|
|
|
OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(xi->value_len)) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xs->not_found) {
|
|
|
|
/* For existing extended attribute */
|
|
|
|
size_t size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
|
|
|
|
size_t offs = le16_to_cpu(xs->here->xe_name_offset);
|
|
|
|
void *val = xs->base + offs;
|
|
|
|
|
|
|
|
if (ocfs2_xattr_is_local(xs->here) && size == size_l) {
|
|
|
|
/* Replace existing local xattr with tree root */
|
|
|
|
ret = ocfs2_xattr_set_value_outside(inode, xi, xs,
|
2008-12-09 16:58:35 -07:00
|
|
|
ctxt, &vb, offs);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
} else if (!ocfs2_xattr_is_local(xs->here)) {
|
|
|
|
/* For existing xattr which has value outside */
|
2008-12-09 16:58:35 -07:00
|
|
|
vb.vb_xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(val + OCFS2_XATTR_SIZE(name_len));
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
/*
|
|
|
|
* If new value need set outside also,
|
|
|
|
* first truncate old value to new value,
|
|
|
|
* then set new value with set_value_outside().
|
|
|
|
*/
|
|
|
|
ret = ocfs2_xattr_value_truncate(inode,
|
2008-12-09 16:01:04 -07:00
|
|
|
&vb,
|
2008-11-11 17:27:00 -07:00
|
|
|
xi->value_len,
|
|
|
|
ctxt);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
ret = ocfs2_xattr_update_entry(inode,
|
|
|
|
handle,
|
|
|
|
xi,
|
|
|
|
xs,
|
2008-12-09 16:46:15 -07:00
|
|
|
&vb,
|
2008-11-11 17:27:01 -07:00
|
|
|
offs);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
ret = __ocfs2_xattr_set_value_outside(inode,
|
|
|
|
handle,
|
2009-08-17 21:43:17 -06:00
|
|
|
&vb,
|
2008-11-11 17:27:01 -07:00
|
|
|
xi->value,
|
|
|
|
xi->value_len);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If new value need set in local,
|
|
|
|
* just trucate old value to zero.
|
|
|
|
*/
|
|
|
|
ret = ocfs2_xattr_value_truncate(inode,
|
2008-12-09 16:01:04 -07:00
|
|
|
&vb,
|
2008-11-11 17:27:01 -07:00
|
|
|
0,
|
|
|
|
ctxt);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), xs->inode_bh,
|
2008-12-09 16:58:35 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flag & OCFS2_INLINE_XATTR_FL)) {
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = vb.vb_access(handle, INODE_CACHE(inode), vb.vb_bh,
|
2008-12-09 16:58:35 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set value in local, include set tree root in local.
|
|
|
|
* This is the first step for value size >INLINE_SIZE.
|
|
|
|
*/
|
|
|
|
ocfs2_xattr_set_entry_local(inode, &xi_l, xs, last, min_offs);
|
|
|
|
|
|
|
|
if (!(flag & OCFS2_INLINE_XATTR_FL)) {
|
|
|
|
ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) &&
|
|
|
|
(flag & OCFS2_INLINE_XATTR_FL)) {
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
unsigned int xattrsize = osb->s_xattr_inline_size;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust extent record count or inline data size
|
|
|
|
* to reserve space for extended attribute.
|
|
|
|
*/
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
|
|
|
|
struct ocfs2_inline_data *idata = &di->id2.i_data;
|
|
|
|
le16_add_cpu(&idata->id_count, -xattrsize);
|
|
|
|
} else if (!(ocfs2_inode_is_fast_symlink(inode))) {
|
|
|
|
struct ocfs2_extent_list *el = &di->id2.i_list;
|
|
|
|
le16_add_cpu(&el->l_count, -(xattrsize /
|
|
|
|
sizeof(struct ocfs2_extent_rec)));
|
|
|
|
}
|
|
|
|
di->i_xattr_inline_size = cpu_to_le16(xattrsize);
|
|
|
|
}
|
|
|
|
/* Update xattr flag */
|
|
|
|
spin_lock(&oi->ip_lock);
|
|
|
|
oi->ip_dyn_features |= flag;
|
|
|
|
di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
|
|
|
|
spin_unlock(&oi->ip_lock);
|
|
|
|
|
|
|
|
ret = ocfs2_journal_dirty(handle, xs->inode_bh);
|
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
if (!ret && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
/*
|
|
|
|
* Set value outside in B tree.
|
|
|
|
* This is the second step for value size > INLINE_SIZE.
|
|
|
|
*/
|
|
|
|
size_t offs = le16_to_cpu(xs->here->xe_name_offset);
|
2008-12-09 16:58:35 -07:00
|
|
|
ret = ocfs2_xattr_set_value_outside(inode, xi, xs, ctxt,
|
|
|
|
&vb, offs);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
int ret2;
|
|
|
|
|
|
|
|
mlog_errno(ret);
|
|
|
|
/*
|
|
|
|
* If set value outside failed, we have to clean
|
|
|
|
* the junk tree root we have already set in local.
|
|
|
|
*/
|
2008-11-11 17:27:01 -07:00
|
|
|
ret2 = ocfs2_xattr_cleanup(inode, ctxt->handle,
|
2008-12-09 16:58:35 -07:00
|
|
|
xi, xs, &vb, offs);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret2 < 0)
|
|
|
|
mlog_errno(ret2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
/*
|
|
|
|
* In xattr remove, if it is stored outside and refcounted, we may have
|
|
|
|
* the chance to split the refcount tree. So need the allocators.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret, meta_add = 0;
|
|
|
|
u32 p_cluster, num_clusters;
|
|
|
|
unsigned int ext_flags;
|
|
|
|
|
|
|
|
*ref_credits = 0;
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
|
|
|
|
&num_clusters,
|
|
|
|
&xv->xr_list,
|
|
|
|
&ext_flags);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ocfs2_refcounted_xattr_delete_need(inode, ref_ci,
|
|
|
|
ref_root_bh, xv,
|
|
|
|
&meta_add, ref_credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb),
|
|
|
|
meta_add, meta_ac);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
static int ocfs2_remove_value_outside(struct inode*inode,
|
2008-12-09 17:24:43 -07:00
|
|
|
struct ocfs2_xattr_value_buf *vb,
|
2009-08-17 21:43:59 -06:00
|
|
|
struct ocfs2_xattr_header *header,
|
|
|
|
struct ocfs2_caching_info *ref_ci,
|
|
|
|
struct buffer_head *ref_root_bh)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
2009-08-17 21:43:59 -06:00
|
|
|
int ret = 0, i, ref_credits;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
|
2009-08-17 21:43:59 -06:00
|
|
|
void *val;
|
2008-11-11 17:27:00 -07:00
|
|
|
|
|
|
|
ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
|
|
|
|
struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
if (ocfs2_xattr_is_local(entry))
|
|
|
|
continue;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
val = (void *)header +
|
|
|
|
le16_to_cpu(entry->xe_name_offset);
|
|
|
|
vb->vb_xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(val + OCFS2_XATTR_SIZE(entry->xe_name_len));
|
|
|
|
|
|
|
|
ret = ocfs2_lock_xattr_remove_allocators(inode, vb->vb_xv,
|
|
|
|
ref_ci, ref_root_bh,
|
|
|
|
&ctxt.meta_ac,
|
|
|
|
&ref_credits);
|
|
|
|
|
|
|
|
ctxt.handle = ocfs2_start_trans(osb, ref_credits +
|
|
|
|
ocfs2_remove_extent_credits(osb->sb));
|
|
|
|
if (IS_ERR(ctxt.handle)) {
|
|
|
|
ret = PTR_ERR(ctxt.handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_value_truncate(inode, vb, 0, &ctxt);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_commit_trans(osb, ctxt.handle);
|
|
|
|
if (ctxt.meta_ac) {
|
|
|
|
ocfs2_free_alloc_context(ctxt.meta_ac);
|
|
|
|
ctxt.meta_ac = NULL;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
if (ctxt.meta_ac)
|
|
|
|
ocfs2_free_alloc_context(ctxt.meta_ac);
|
2008-11-11 17:27:00 -07:00
|
|
|
ocfs2_schedule_truncate_log_flush(osb, 1);
|
|
|
|
ocfs2_run_deallocs(osb, &ctxt.dealloc);
|
2008-08-18 03:11:00 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_ibody_remove(struct inode *inode,
|
2009-08-17 21:43:59 -06:00
|
|
|
struct buffer_head *di_bh,
|
|
|
|
struct ocfs2_caching_info *ref_ci,
|
|
|
|
struct buffer_head *ref_root_bh)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
|
|
|
|
struct ocfs2_xattr_header *header;
|
|
|
|
int ret;
|
2008-12-09 17:24:43 -07:00
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = di_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_di,
|
|
|
|
};
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
header = (struct ocfs2_xattr_header *)
|
|
|
|
((void *)di + inode->i_sb->s_blocksize -
|
|
|
|
le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
ret = ocfs2_remove_value_outside(inode, &vb, header,
|
|
|
|
ref_ci, ref_root_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
struct ocfs2_rm_xattr_bucket_para {
|
|
|
|
struct ocfs2_caching_info *ref_ci;
|
|
|
|
struct buffer_head *ref_root_bh;
|
|
|
|
};
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
static int ocfs2_xattr_block_remove(struct inode *inode,
|
2009-08-17 21:43:59 -06:00
|
|
|
struct buffer_head *blk_bh,
|
|
|
|
struct ocfs2_caching_info *ref_ci,
|
|
|
|
struct buffer_head *ref_root_bh)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
struct ocfs2_xattr_block *xb;
|
|
|
|
int ret = 0;
|
2008-12-09 17:24:43 -07:00
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = blk_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_xb,
|
|
|
|
};
|
2009-08-17 21:43:59 -06:00
|
|
|
struct ocfs2_rm_xattr_bucket_para args = {
|
|
|
|
.ref_ci = ref_ci,
|
|
|
|
.ref_root_bh = ref_root_bh,
|
|
|
|
};
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
|
2008-08-18 03:38:54 -06:00
|
|
|
if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
|
|
|
|
struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header);
|
2009-08-17 21:43:59 -06:00
|
|
|
ret = ocfs2_remove_value_outside(inode, &vb, header,
|
|
|
|
ref_ci, ref_root_bh);
|
2008-08-18 03:38:54 -06:00
|
|
|
} else
|
2009-08-17 21:43:42 -06:00
|
|
|
ret = ocfs2_iterate_xattr_index_block(inode,
|
|
|
|
blk_bh,
|
|
|
|
ocfs2_rm_xattr_cluster,
|
2009-08-17 21:43:59 -06:00
|
|
|
&args);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-28 19:00:19 -06:00
|
|
|
static int ocfs2_xattr_free_block(struct inode *inode,
|
2009-08-17 21:43:59 -06:00
|
|
|
u64 block,
|
|
|
|
struct ocfs2_caching_info *ref_ci,
|
|
|
|
struct buffer_head *ref_root_bh)
|
2008-08-28 19:00:19 -06:00
|
|
|
{
|
|
|
|
struct inode *xb_alloc_inode;
|
|
|
|
struct buffer_head *xb_alloc_bh = NULL;
|
|
|
|
struct buffer_head *blk_bh = NULL;
|
|
|
|
struct ocfs2_xattr_block *xb;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
handle_t *handle;
|
|
|
|
int ret = 0;
|
|
|
|
u64 blk, bg_blkno;
|
|
|
|
u16 bit;
|
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
ret = ocfs2_read_xattr_block(inode, block, &blk_bh);
|
2008-08-28 19:00:19 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
ret = ocfs2_xattr_block_remove(inode, blk_bh, ref_ci, ref_root_bh);
|
2008-08-28 19:00:19 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
|
2008-08-28 19:00:19 -06:00
|
|
|
blk = le64_to_cpu(xb->xb_blkno);
|
|
|
|
bit = le16_to_cpu(xb->xb_suballoc_bit);
|
|
|
|
bg_blkno = ocfs2_which_suballoc_group(blk, bit);
|
|
|
|
|
|
|
|
xb_alloc_inode = ocfs2_get_system_file_inode(osb,
|
|
|
|
EXTENT_ALLOC_SYSTEM_INODE,
|
|
|
|
le16_to_cpu(xb->xb_suballoc_slot));
|
|
|
|
if (!xb_alloc_inode) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
mutex_lock(&xb_alloc_inode->i_mutex);
|
|
|
|
|
|
|
|
ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_mutex;
|
|
|
|
}
|
|
|
|
|
|
|
|
handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh,
|
|
|
|
bit, bg_blkno, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
out_unlock:
|
|
|
|
ocfs2_inode_unlock(xb_alloc_inode, 1);
|
|
|
|
brelse(xb_alloc_bh);
|
|
|
|
out_mutex:
|
|
|
|
mutex_unlock(&xb_alloc_inode->i_mutex);
|
|
|
|
iput(xb_alloc_inode);
|
|
|
|
out:
|
|
|
|
brelse(blk_bh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
/*
|
|
|
|
* ocfs2_xattr_remove()
|
|
|
|
*
|
|
|
|
* Free extended attribute resources associated with this inode.
|
|
|
|
*/
|
|
|
|
int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
|
|
|
|
{
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
|
2009-08-17 21:43:59 -06:00
|
|
|
struct ocfs2_refcount_tree *ref_tree = NULL;
|
|
|
|
struct buffer_head *ref_root_bh = NULL;
|
|
|
|
struct ocfs2_caching_info *ref_ci = NULL;
|
2008-08-18 03:11:00 -06:00
|
|
|
handle_t *handle;
|
|
|
|
int ret;
|
|
|
|
|
2008-08-18 03:11:46 -06:00
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
|
|
|
|
return 0;
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
|
|
|
|
return 0;
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) {
|
|
|
|
ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb),
|
|
|
|
le64_to_cpu(di->i_refcount_loc),
|
|
|
|
1, &ref_tree, &ref_root_bh);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ref_ci = &ref_tree->rf_ci;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
|
2009-08-17 21:43:59 -06:00
|
|
|
ret = ocfs2_xattr_ibody_remove(inode, di_bh,
|
|
|
|
ref_ci, ref_root_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-28 19:00:19 -06:00
|
|
|
if (di->i_xattr_loc) {
|
|
|
|
ret = ocfs2_xattr_free_block(inode,
|
2009-08-17 21:43:59 -06:00
|
|
|
le64_to_cpu(di->i_xattr_loc),
|
|
|
|
ref_ci, ref_root_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
|
|
|
|
OCFS2_INODE_UPDATE_CREDITS);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
|
2008-12-09 17:11:49 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
2008-08-28 19:00:19 -06:00
|
|
|
di->i_xattr_loc = 0;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
spin_lock(&oi->ip_lock);
|
|
|
|
oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
|
|
|
|
di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
|
|
|
|
spin_unlock(&oi->ip_lock);
|
|
|
|
|
|
|
|
ret = ocfs2_journal_dirty(handle, di_bh);
|
|
|
|
if (ret < 0)
|
|
|
|
mlog_errno(ret);
|
|
|
|
out_commit:
|
|
|
|
ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
|
|
|
|
out:
|
2009-08-17 21:43:59 -06:00
|
|
|
if (ref_tree)
|
|
|
|
ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1);
|
|
|
|
brelse(ref_root_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_has_space_inline(struct inode *inode,
|
|
|
|
struct ocfs2_dinode *di)
|
|
|
|
{
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
|
|
|
|
int free;
|
|
|
|
|
|
|
|
if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
|
|
|
|
struct ocfs2_inline_data *idata = &di->id2.i_data;
|
|
|
|
free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size);
|
|
|
|
} else if (ocfs2_inode_is_fast_symlink(inode)) {
|
|
|
|
free = ocfs2_fast_symlink_chars(inode->i_sb) -
|
|
|
|
le64_to_cpu(di->i_size);
|
|
|
|
} else {
|
|
|
|
struct ocfs2_extent_list *el = &di->id2.i_list;
|
|
|
|
free = (le16_to_cpu(el->l_count) -
|
|
|
|
le16_to_cpu(el->l_next_free_rec)) *
|
|
|
|
sizeof(struct ocfs2_extent_rec);
|
|
|
|
}
|
|
|
|
if (free >= xattrsize)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_ibody_find()
|
|
|
|
*
|
|
|
|
* Find extended attribute in inode block and
|
|
|
|
* fill search info into struct ocfs2_xattr_search.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_ibody_find(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
|
|
|
|
int ret;
|
|
|
|
int has_space = 0;
|
|
|
|
|
|
|
|
if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
|
|
|
|
down_read(&oi->ip_alloc_sem);
|
|
|
|
has_space = ocfs2_xattr_has_space_inline(inode, di);
|
|
|
|
up_read(&oi->ip_alloc_sem);
|
|
|
|
if (!has_space)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
xs->xattr_bh = xs->inode_bh;
|
|
|
|
xs->end = (void *)di + inode->i_sb->s_blocksize;
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
|
|
|
|
xs->header = (struct ocfs2_xattr_header *)
|
|
|
|
(xs->end - le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
else
|
|
|
|
xs->header = (struct ocfs2_xattr_header *)
|
|
|
|
(xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size);
|
|
|
|
xs->base = (void *)xs->header;
|
|
|
|
xs->here = xs->header->xh_entries;
|
|
|
|
|
|
|
|
/* Find the named attribute. */
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
|
|
|
|
ret = ocfs2_xattr_find_entry(name_index, name, xs);
|
|
|
|
if (ret && ret != -ENODATA)
|
|
|
|
return ret;
|
|
|
|
xs->not_found = ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_ibody_set()
|
|
|
|
*
|
|
|
|
* Set, replace or remove an extended attribute into inode block.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_ibody_set(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
down_write(&oi->ip_alloc_sem);
|
|
|
|
if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
|
|
|
|
if (!ocfs2_xattr_has_space_inline(inode, di)) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = ocfs2_xattr_set_entry(inode, xi, xs, ctxt,
|
2008-08-18 03:11:00 -06:00
|
|
|
(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL));
|
|
|
|
out:
|
|
|
|
up_write(&oi->ip_alloc_sem);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ocfs2_xattr_block_find()
|
|
|
|
*
|
|
|
|
* Find extended attribute in external block and
|
|
|
|
* fill search info into struct ocfs2_xattr_search.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_block_find(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
|
|
|
|
struct buffer_head *blk_bh = NULL;
|
2008-08-18 03:38:51 -06:00
|
|
|
struct ocfs2_xattr_block *xb;
|
2008-08-18 03:11:00 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!di->i_xattr_loc)
|
|
|
|
return ret;
|
|
|
|
|
2008-11-13 15:49:18 -07:00
|
|
|
ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
|
|
|
|
&blk_bh);
|
2008-08-18 03:11:00 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-10-20 19:20:43 -06:00
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
xs->xattr_bh = blk_bh;
|
2008-11-13 15:49:18 -07:00
|
|
|
xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
|
2008-08-18 03:38:51 -06:00
|
|
|
|
|
|
|
if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
|
|
|
|
xs->header = &xb->xb_attrs.xb_header;
|
|
|
|
xs->base = (void *)xs->header;
|
|
|
|
xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
|
|
|
|
xs->here = xs->header->xh_entries;
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_find_entry(name_index, name, xs);
|
|
|
|
} else
|
|
|
|
ret = ocfs2_xattr_index_block_find(inode, blk_bh,
|
|
|
|
name_index,
|
|
|
|
name, xs);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
if (ret && ret != -ENODATA) {
|
|
|
|
xs->xattr_bh = NULL;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
xs->not_found = ret;
|
|
|
|
return 0;
|
|
|
|
cleanup:
|
|
|
|
brelse(blk_bh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:24 -06:00
|
|
|
static int ocfs2_create_xattr_block(handle_t *handle,
|
|
|
|
struct inode *inode,
|
|
|
|
struct buffer_head *inode_bh,
|
|
|
|
struct ocfs2_alloc_context *meta_ac,
|
2009-08-17 21:43:52 -06:00
|
|
|
struct buffer_head **ret_bh,
|
|
|
|
int indexed)
|
2009-08-17 21:43:24 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u16 suballoc_bit_start;
|
|
|
|
u32 num_got;
|
|
|
|
u64 first_blkno;
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)inode_bh->b_data;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct buffer_head *new_bh = NULL;
|
|
|
|
struct ocfs2_xattr_block *xblk;
|
|
|
|
|
|
|
|
ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), inode_bh,
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
|
|
|
|
&suballoc_bit_start, &num_got,
|
|
|
|
&first_blkno);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_bh = sb_getblk(inode->i_sb, first_blkno);
|
|
|
|
ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);
|
|
|
|
|
|
|
|
ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode),
|
|
|
|
new_bh,
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize ocfs2_xattr_block */
|
|
|
|
xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
|
|
|
|
memset(xblk, 0, inode->i_sb->s_blocksize);
|
|
|
|
strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
|
|
|
|
xblk->xb_suballoc_slot = cpu_to_le16(osb->slot_num);
|
|
|
|
xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
|
|
|
|
xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation);
|
|
|
|
xblk->xb_blkno = cpu_to_le64(first_blkno);
|
|
|
|
|
2009-08-17 21:43:52 -06:00
|
|
|
if (indexed) {
|
|
|
|
struct ocfs2_xattr_tree_root *xr = &xblk->xb_attrs.xb_root;
|
|
|
|
xr->xt_clusters = cpu_to_le32(1);
|
|
|
|
xr->xt_last_eb_blk = 0;
|
|
|
|
xr->xt_list.l_tree_depth = 0;
|
|
|
|
xr->xt_list.l_count = cpu_to_le16(
|
|
|
|
ocfs2_xattr_recs_per_xb(inode->i_sb));
|
|
|
|
xr->xt_list.l_next_free_rec = cpu_to_le16(1);
|
|
|
|
xblk->xb_flags = cpu_to_le16(OCFS2_XATTR_INDEXED);
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:24 -06:00
|
|
|
ret = ocfs2_journal_dirty(handle, new_bh);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
di->i_xattr_loc = cpu_to_le64(first_blkno);
|
|
|
|
ocfs2_journal_dirty(handle, inode_bh);
|
|
|
|
|
|
|
|
*ret_bh = new_bh;
|
|
|
|
new_bh = NULL;
|
|
|
|
|
|
|
|
end:
|
|
|
|
brelse(new_bh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
/*
|
|
|
|
* ocfs2_xattr_block_set()
|
|
|
|
*
|
|
|
|
* Set, replace or remove an extended attribute into external block.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_block_set(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
2008-08-18 03:11:00 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *new_bh = NULL;
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
2008-08-18 03:11:00 -06:00
|
|
|
struct ocfs2_xattr_block *xblk = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!xs->xattr_bh) {
|
2009-08-17 21:43:24 -06:00
|
|
|
ret = ocfs2_create_xattr_block(handle, inode, xs->inode_bh,
|
2009-08-17 21:43:52 -06:00
|
|
|
ctxt->meta_ac, &new_bh, 0);
|
2009-08-17 21:43:24 -06:00
|
|
|
if (ret) {
|
2008-08-18 03:11:00 -06:00
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto end;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xs->xattr_bh = new_bh;
|
2009-08-17 21:43:24 -06:00
|
|
|
xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
|
2008-08-18 03:11:00 -06:00
|
|
|
xs->header = &xblk->xb_attrs.xb_header;
|
|
|
|
xs->base = (void *)xs->header;
|
|
|
|
xs->end = (void *)xblk + inode->i_sb->s_blocksize;
|
|
|
|
xs->here = xs->header->xh_entries;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
} else
|
|
|
|
xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
|
|
|
|
|
|
|
|
if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
|
|
|
|
/* Set extended attribute into external block */
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = ocfs2_xattr_set_entry(inode, xi, xs, ctxt,
|
|
|
|
OCFS2_HAS_XATTR_FL);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (!ret || ret != -ENOSPC)
|
|
|
|
goto end;
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = ocfs2_xattr_create_index_block(inode, xs, ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret)
|
|
|
|
goto end;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs, ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
end:
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
/* Check whether the new xattr can be inserted into the inode. */
|
|
|
|
static int ocfs2_xattr_can_be_in_inode(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
u64 value_size;
|
|
|
|
struct ocfs2_xattr_entry *last;
|
|
|
|
int free, i;
|
|
|
|
size_t min_offs = xs->end - xs->base;
|
|
|
|
|
|
|
|
if (!xs->header)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
last = xs->header->xh_entries;
|
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
|
|
|
|
size_t offs = le16_to_cpu(last->xe_name_offset);
|
|
|
|
if (offs < min_offs)
|
|
|
|
min_offs = offs;
|
|
|
|
last += 1;
|
|
|
|
}
|
|
|
|
|
2009-02-19 20:11:50 -07:00
|
|
|
free = min_offs - ((void *)last - xs->base) - OCFS2_XATTR_HEADER_GAP;
|
2008-11-11 17:27:00 -07:00
|
|
|
if (free < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
BUG_ON(!xs->not_found);
|
|
|
|
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
value_size = OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
else
|
|
|
|
value_size = OCFS2_XATTR_SIZE(xi->value_len);
|
|
|
|
|
|
|
|
if (free >= sizeof(struct ocfs2_xattr_entry) +
|
|
|
|
OCFS2_XATTR_SIZE(strlen(xi->name)) + value_size)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int 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,
|
2008-11-11 17:27:01 -07:00
|
|
|
int *meta_need,
|
|
|
|
int *credits_need)
|
2008-11-11 17:27:00 -07:00
|
|
|
{
|
|
|
|
int ret = 0, old_in_xb = 0;
|
2008-11-11 17:27:01 -07:00
|
|
|
int clusters_add = 0, meta_add = 0, credits = 0;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct ocfs2_xattr_block *xb = NULL;
|
|
|
|
struct ocfs2_xattr_entry *xe = NULL;
|
|
|
|
struct ocfs2_xattr_value_root *xv = NULL;
|
|
|
|
char *base = NULL;
|
|
|
|
int name_offset, name_len = 0;
|
|
|
|
u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
|
|
|
|
xi->value_len);
|
|
|
|
u64 value_size;
|
|
|
|
|
2008-12-04 15:20:54 -07:00
|
|
|
/*
|
|
|
|
* Calculate the clusters we need to write.
|
|
|
|
* No matter whether we replace an old one or add a new one,
|
|
|
|
* we need this for writing.
|
|
|
|
*/
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
credits += new_clusters *
|
|
|
|
ocfs2_clusters_to_blocks(inode->i_sb, 1);
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
if (xis->not_found && xbs->not_found) {
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
|
|
|
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
2008-11-11 17:27:00 -07:00
|
|
|
clusters_add += new_clusters;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_calc_extend_credits(inode->i_sb,
|
|
|
|
&def_xv.xv.xr_list,
|
|
|
|
new_clusters);
|
|
|
|
}
|
2008-11-11 17:27:00 -07:00
|
|
|
|
|
|
|
goto meta_guess;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xis->not_found) {
|
|
|
|
xe = xis->here;
|
|
|
|
name_offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
base = xis->base;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += OCFS2_INODE_UPDATE_CREDITS;
|
2008-11-11 17:27:00 -07:00
|
|
|
} else {
|
2008-11-13 15:49:19 -07:00
|
|
|
int i, block_off = 0;
|
2008-11-11 17:27:00 -07:00
|
|
|
xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
|
|
|
|
xe = xbs->here;
|
|
|
|
name_offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
i = xbs->here - xbs->header->xh_entries;
|
|
|
|
old_in_xb = 1;
|
|
|
|
|
|
|
|
if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
|
2008-11-11 17:27:00 -07:00
|
|
|
bucket_xh(xbs->bucket),
|
|
|
|
i, &block_off,
|
|
|
|
&name_offset);
|
|
|
|
base = bucket_block(xbs->bucket, block_off);
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
|
|
|
} else {
|
2008-11-11 17:27:00 -07:00
|
|
|
base = xbs->base;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += OCFS2_XATTR_BLOCK_UPDATE_CREDITS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* delete a xattr doesn't need metadata and cluster allocation.
|
|
|
|
* so just calculate the credits and return.
|
|
|
|
*
|
|
|
|
* The credits for removing the value tree will be extended
|
|
|
|
* by ocfs2_remove_extent itself.
|
|
|
|
*/
|
|
|
|
if (!xi->value) {
|
|
|
|
if (!ocfs2_xattr_is_local(xe))
|
2008-10-09 11:38:40 -06:00
|
|
|
credits += ocfs2_remove_extent_credits(inode->i_sb);
|
2008-11-11 17:27:01 -07:00
|
|
|
|
|
|
|
goto out;
|
2008-11-11 17:27:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* do cluster allocation guess first. */
|
|
|
|
value_size = le64_to_cpu(xe->xe_value_size);
|
|
|
|
|
|
|
|
if (old_in_xb) {
|
|
|
|
/*
|
|
|
|
* In xattr set, we always try to set the xe in inode first,
|
|
|
|
* so if it can be inserted into inode successfully, the old
|
|
|
|
* one will be removed from the xattr block, and this xattr
|
|
|
|
* will be inserted into inode as a new xattr in inode.
|
|
|
|
*/
|
|
|
|
if (ocfs2_xattr_can_be_in_inode(inode, xi, xis)) {
|
|
|
|
clusters_add += new_clusters;
|
2008-10-09 11:38:40 -06:00
|
|
|
credits += ocfs2_remove_extent_credits(inode->i_sb) +
|
2008-11-11 17:27:01 -07:00
|
|
|
OCFS2_INODE_UPDATE_CREDITS;
|
|
|
|
if (!ocfs2_xattr_is_local(xe))
|
|
|
|
credits += ocfs2_calc_extend_credits(
|
|
|
|
inode->i_sb,
|
|
|
|
&def_xv.xv.xr_list,
|
|
|
|
new_clusters);
|
2008-11-11 17:27:00 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
/* the new values will be stored outside. */
|
|
|
|
u32 old_clusters = 0;
|
|
|
|
|
|
|
|
if (!ocfs2_xattr_is_local(xe)) {
|
|
|
|
old_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
|
|
|
|
value_size);
|
|
|
|
xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(base + name_offset + name_len);
|
2008-11-19 01:48:41 -07:00
|
|
|
value_size = OCFS2_XATTR_ROOT_SIZE;
|
2008-11-11 17:27:00 -07:00
|
|
|
} else
|
|
|
|
xv = &def_xv.xv;
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
if (old_clusters >= new_clusters) {
|
2008-10-09 11:38:40 -06:00
|
|
|
credits += ocfs2_remove_extent_credits(inode->i_sb);
|
2008-11-11 17:27:00 -07:00
|
|
|
goto out;
|
2008-11-11 17:27:01 -07:00
|
|
|
} else {
|
2008-11-11 17:27:00 -07:00
|
|
|
meta_add += ocfs2_extend_meta_needed(&xv->xr_list);
|
|
|
|
clusters_add += new_clusters - old_clusters;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_calc_extend_credits(inode->i_sb,
|
|
|
|
&xv->xr_list,
|
|
|
|
new_clusters -
|
|
|
|
old_clusters);
|
2008-11-19 01:48:41 -07:00
|
|
|
if (value_size >= OCFS2_XATTR_ROOT_SIZE)
|
|
|
|
goto out;
|
2008-11-11 17:27:00 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Now the new value will be stored inside. So if the new
|
|
|
|
* value is smaller than the size of value root or the old
|
|
|
|
* value, we don't need any allocation, otherwise we have
|
|
|
|
* to guess metadata allocation.
|
|
|
|
*/
|
|
|
|
if ((ocfs2_xattr_is_local(xe) && value_size >= xi->value_len) ||
|
|
|
|
(!ocfs2_xattr_is_local(xe) &&
|
|
|
|
OCFS2_XATTR_ROOT_SIZE >= xi->value_len))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
meta_guess:
|
|
|
|
/* calculate metadata allocation. */
|
|
|
|
if (di->i_xattr_loc) {
|
|
|
|
if (!xbs->xattr_bh) {
|
2008-11-13 15:49:18 -07:00
|
|
|
ret = ocfs2_read_xattr_block(inode,
|
|
|
|
le64_to_cpu(di->i_xattr_loc),
|
|
|
|
&bh);
|
2008-11-11 17:27:00 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
xb = (struct ocfs2_xattr_block *)bh->b_data;
|
|
|
|
} else
|
|
|
|
xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
|
|
|
|
|
2008-12-04 15:20:56 -07:00
|
|
|
/*
|
|
|
|
* If there is already an xattr tree, good, we can calculate
|
|
|
|
* like other b-trees. Otherwise we may have the chance of
|
|
|
|
* create a tree, the credit calculation is borrowed from
|
|
|
|
* ocfs2_calc_extend_credits with root_el = NULL. And the
|
|
|
|
* new tree will be cluster based, so no meta is needed.
|
|
|
|
*/
|
2008-11-11 17:27:00 -07:00
|
|
|
if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
|
|
|
|
struct ocfs2_extent_list *el =
|
|
|
|
&xb->xb_attrs.xb_root.xt_list;
|
|
|
|
meta_add += ocfs2_extend_meta_needed(el);
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_calc_extend_credits(inode->i_sb,
|
|
|
|
el, 1);
|
2008-12-04 15:20:56 -07:00
|
|
|
} else
|
|
|
|
credits += OCFS2_SUBALLOC_ALLOC + 1;
|
2008-11-11 17:27:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This cluster will be used either for new bucket or for
|
|
|
|
* new xattr block.
|
|
|
|
* If the cluster size is the same as the bucket size, one
|
|
|
|
* more is needed since we may need to extend the bucket
|
|
|
|
* also.
|
|
|
|
*/
|
|
|
|
clusters_add += 1;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2008-11-11 17:27:00 -07:00
|
|
|
if (OCFS2_XATTR_BUCKET_SIZE ==
|
2008-11-11 17:27:01 -07:00
|
|
|
OCFS2_SB(inode->i_sb)->s_clustersize) {
|
|
|
|
credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2008-11-11 17:27:00 -07:00
|
|
|
clusters_add += 1;
|
2008-11-11 17:27:01 -07:00
|
|
|
}
|
|
|
|
} else {
|
2008-11-11 17:27:00 -07:00
|
|
|
meta_add += 1;
|
2008-11-11 17:27:01 -07:00
|
|
|
credits += OCFS2_XATTR_BLOCK_CREATE_CREDITS;
|
|
|
|
}
|
2008-11-11 17:27:00 -07:00
|
|
|
out:
|
|
|
|
if (clusters_need)
|
|
|
|
*clusters_need = clusters_add;
|
|
|
|
if (meta_need)
|
|
|
|
*meta_need = meta_add;
|
2008-11-11 17:27:01 -07:00
|
|
|
if (credits_need)
|
|
|
|
*credits_need = credits;
|
2008-11-11 17:27:00 -07:00
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int 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,
|
2008-11-11 17:27:01 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt,
|
2009-08-17 21:43:17 -06:00
|
|
|
int extra_meta,
|
2008-11-11 17:27:01 -07:00
|
|
|
int *credits)
|
2008-11-11 17:27:00 -07:00
|
|
|
{
|
|
|
|
int clusters_add, meta_add, ret;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
|
|
|
|
memset(ctxt, 0, sizeof(struct ocfs2_xattr_set_ctxt));
|
|
|
|
|
|
|
|
ocfs2_init_dealloc_ctxt(&ctxt->dealloc);
|
|
|
|
|
|
|
|
ret = ocfs2_calc_xattr_set_need(inode, di, xi, xis, xbs,
|
2008-11-11 17:27:01 -07:00
|
|
|
&clusters_add, &meta_add, credits);
|
2008-11-11 17:27:00 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
meta_add += extra_meta;
|
2008-11-11 17:27:01 -07:00
|
|
|
mlog(0, "Set xattr %s, reserve meta blocks = %d, clusters = %d, "
|
|
|
|
"credits = %d\n", xi->name, meta_add, clusters_add, *credits);
|
2008-11-11 17:27:00 -07:00
|
|
|
|
|
|
|
if (meta_add) {
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add,
|
|
|
|
&ctxt->meta_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clusters_add) {
|
|
|
|
ret = ocfs2_reserve_clusters(osb, clusters_add, &ctxt->data_ac);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (ret) {
|
|
|
|
if (ctxt->meta_ac) {
|
|
|
|
ocfs2_free_alloc_context(ctxt->meta_ac);
|
|
|
|
ctxt->meta_ac = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We cannot have an error and a non null ctxt->data_ac.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
static int __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)
|
|
|
|
{
|
2008-11-19 01:48:42 -07:00
|
|
|
int ret = 0, credits, old_found;
|
2008-11-11 17:27:01 -07:00
|
|
|
|
|
|
|
if (!xi->value) {
|
|
|
|
/* Remove existing extended attribute */
|
|
|
|
if (!xis->not_found)
|
|
|
|
ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
|
|
|
|
else if (!xbs->not_found)
|
|
|
|
ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
|
|
|
|
} else {
|
|
|
|
/* We always try to set extended attribute into inode first*/
|
|
|
|
ret = ocfs2_xattr_ibody_set(inode, xi, xis, ctxt);
|
|
|
|
if (!ret && !xbs->not_found) {
|
|
|
|
/*
|
|
|
|
* If succeed and that extended attribute existing in
|
|
|
|
* external block, then we will remove it.
|
|
|
|
*/
|
|
|
|
xi->value = NULL;
|
|
|
|
xi->value_len = 0;
|
|
|
|
|
2008-11-19 01:48:42 -07:00
|
|
|
old_found = xis->not_found;
|
2008-11-11 17:27:01 -07:00
|
|
|
xis->not_found = -ENODATA;
|
|
|
|
ret = ocfs2_calc_xattr_set_need(inode,
|
|
|
|
di,
|
|
|
|
xi,
|
|
|
|
xis,
|
|
|
|
xbs,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&credits);
|
2008-11-19 01:48:42 -07:00
|
|
|
xis->not_found = old_found;
|
2008-11-11 17:27:01 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_extend_trans(ctxt->handle, credits +
|
|
|
|
ctxt->handle->h_buffer_credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
|
|
|
|
} else if (ret == -ENOSPC) {
|
|
|
|
if (di->i_xattr_loc && !xbs->xattr_bh) {
|
|
|
|
ret = ocfs2_xattr_block_find(inode,
|
|
|
|
xi->name_index,
|
|
|
|
xi->name, xbs);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2008-11-19 01:48:42 -07:00
|
|
|
old_found = xis->not_found;
|
2008-11-11 17:27:01 -07:00
|
|
|
xis->not_found = -ENODATA;
|
|
|
|
ret = ocfs2_calc_xattr_set_need(inode,
|
|
|
|
di,
|
|
|
|
xi,
|
|
|
|
xis,
|
|
|
|
xbs,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&credits);
|
2008-11-19 01:48:42 -07:00
|
|
|
xis->not_found = old_found;
|
2008-11-11 17:27:01 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_extend_trans(ctxt->handle, credits +
|
|
|
|
ctxt->handle->h_buffer_credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If no space in inode, we will set extended attribute
|
|
|
|
* into external block.
|
|
|
|
*/
|
|
|
|
ret = ocfs2_xattr_block_set(inode, xi, xbs, ctxt);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
if (!xis->not_found) {
|
|
|
|
/*
|
|
|
|
* If succeed and that extended attribute
|
|
|
|
* existing in inode, we will remove it.
|
|
|
|
*/
|
|
|
|
xi->value = NULL;
|
|
|
|
xi->value_len = 0;
|
|
|
|
xbs->not_found = -ENODATA;
|
|
|
|
ret = ocfs2_calc_xattr_set_need(inode,
|
|
|
|
di,
|
|
|
|
xi,
|
|
|
|
xis,
|
|
|
|
xbs,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_extend_trans(ctxt->handle, credits +
|
|
|
|
ctxt->handle->h_buffer_credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = ocfs2_xattr_ibody_set(inode, xi,
|
|
|
|
xis, ctxt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-04 15:20:55 -07:00
|
|
|
if (!ret) {
|
|
|
|
/* Update inode ctime. */
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_di(ctxt->handle, INODE_CACHE(inode),
|
2009-02-16 13:39:28 -07:00
|
|
|
xis->inode_bh,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
2008-12-04 15:20:55 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
inode->i_ctime = CURRENT_TIME;
|
|
|
|
di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
|
|
|
|
di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
|
|
|
|
ocfs2_journal_dirty(ctxt->handle, xis->inode_bh);
|
|
|
|
}
|
2008-11-11 17:27:01 -07:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:16:03 -07:00
|
|
|
/*
|
|
|
|
* This function only called duing creating inode
|
|
|
|
* for init security/acl xattrs of the new inode.
|
2008-12-09 01:43:08 -07:00
|
|
|
* All transanction credits have been reserved in mknod.
|
2008-11-13 20:16:03 -07:00
|
|
|
*/
|
|
|
|
int 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)
|
|
|
|
{
|
|
|
|
struct ocfs2_dinode *di;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
struct ocfs2_xattr_info xi = {
|
|
|
|
.name_index = name_index,
|
|
|
|
.name = name,
|
|
|
|
.value = value,
|
|
|
|
.value_len = value_len,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_search xis = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_search xbs = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_set_ctxt ctxt = {
|
|
|
|
.handle = handle,
|
|
|
|
.meta_ac = meta_ac,
|
|
|
|
.data_ac = data_ac,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-12-09 01:43:08 -07:00
|
|
|
/*
|
|
|
|
* In extreme situation, may need xattr bucket when
|
|
|
|
* block size is too small. And we have already reserved
|
|
|
|
* the credits for bucket in mknod.
|
|
|
|
*/
|
|
|
|
if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) {
|
|
|
|
xbs.bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!xbs.bucket) {
|
|
|
|
mlog_errno(-ENOMEM);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:16:03 -07:00
|
|
|
xis.inode_bh = xbs.inode_bh = di_bh;
|
|
|
|
di = (struct ocfs2_dinode *)di_bh->b_data;
|
|
|
|
|
|
|
|
down_write(&OCFS2_I(inode)->ip_xattr_sem);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
if (xis.not_found) {
|
|
|
|
ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
up_write(&OCFS2_I(inode)->ip_xattr_sem);
|
|
|
|
brelse(xbs.xattr_bh);
|
2008-12-09 01:43:08 -07:00
|
|
|
ocfs2_xattr_bucket_free(xbs.bucket);
|
2008-11-13 20:16:03 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
/*
|
|
|
|
* ocfs2_xattr_set()
|
|
|
|
*
|
|
|
|
* Set, replace or remove an extended attribute for this inode.
|
|
|
|
* value is NULL to remove an existing extended attribute, else either
|
|
|
|
* create or replace an extended attribute.
|
|
|
|
*/
|
|
|
|
int ocfs2_xattr_set(struct inode *inode,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
const void *value,
|
|
|
|
size_t value_len,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct buffer_head *di_bh = NULL;
|
|
|
|
struct ocfs2_dinode *di;
|
2009-08-17 21:43:17 -06:00
|
|
|
int ret, credits, ref_meta = 0, ref_credits = 0;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
2008-11-11 17:27:01 -07:00
|
|
|
struct inode *tl_inode = osb->osb_tl_inode;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt ctxt = { NULL, NULL, };
|
2009-08-17 21:43:17 -06:00
|
|
|
struct ocfs2_refcount_tree *ref_tree = NULL;
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
struct ocfs2_xattr_info xi = {
|
|
|
|
.name_index = name_index,
|
|
|
|
.name = name,
|
|
|
|
.value = value,
|
|
|
|
.value_len = value_len,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_search xis = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_xattr_search xbs = {
|
|
|
|
.not_found = -ENODATA,
|
|
|
|
};
|
|
|
|
|
2008-08-18 03:11:46 -06:00
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
/*
|
|
|
|
* Only xbs will be used on indexed trees. xis doesn't need a
|
|
|
|
* bucket.
|
|
|
|
*/
|
|
|
|
xbs.bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!xbs.bucket) {
|
|
|
|
mlog_errno(-ENOMEM);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
ret = ocfs2_inode_lock(inode, &di_bh, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
2008-10-24 20:13:20 -06:00
|
|
|
goto cleanup_nolock;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
|
|
|
xis.inode_bh = xbs.inode_bh = di_bh;
|
|
|
|
di = (struct ocfs2_dinode *)di_bh->b_data;
|
|
|
|
|
|
|
|
down_write(&OCFS2_I(inode)->ip_xattr_sem);
|
|
|
|
/*
|
|
|
|
* Scan inode and external block to find the same name
|
|
|
|
* extended attribute and collect search infomation.
|
|
|
|
*/
|
|
|
|
ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
if (xis.not_found) {
|
|
|
|
ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xis.not_found && xbs.not_found) {
|
|
|
|
ret = -ENODATA;
|
|
|
|
if (flags & XATTR_REPLACE)
|
|
|
|
goto cleanup;
|
|
|
|
ret = 0;
|
|
|
|
if (!value)
|
|
|
|
goto cleanup;
|
|
|
|
} else {
|
|
|
|
ret = -EEXIST;
|
|
|
|
if (flags & XATTR_CREATE)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
/* Check whether the value is refcounted and do some prepartion. */
|
|
|
|
if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL &&
|
|
|
|
(!xis.not_found || !xbs.not_found)) {
|
|
|
|
ret = ocfs2_prepare_refcount_xattr(inode, di, &xi,
|
|
|
|
&xis, &xbs, &ref_tree,
|
|
|
|
&ref_meta, &ref_credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
2008-11-11 17:27:01 -07:00
|
|
|
|
|
|
|
mutex_lock(&tl_inode->i_mutex);
|
|
|
|
|
|
|
|
if (ocfs2_truncate_log_needs_flush(osb)) {
|
|
|
|
ret = __ocfs2_flush_truncate_log(osb);
|
|
|
|
if (ret < 0) {
|
|
|
|
mutex_unlock(&tl_inode->i_mutex);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&tl_inode->i_mutex);
|
|
|
|
|
|
|
|
ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
|
2009-08-17 21:43:17 -06:00
|
|
|
&xbs, &ctxt, ref_meta, &credits);
|
2008-11-11 17:27:00 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2008-12-04 15:20:55 -07:00
|
|
|
/* we need to update inode's ctime field, so add credit for it. */
|
|
|
|
credits += OCFS2_INODE_UPDATE_CREDITS;
|
2009-08-17 21:43:17 -06:00
|
|
|
ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
|
2008-11-11 17:27:01 -07:00
|
|
|
if (IS_ERR(ctxt.handle)) {
|
|
|
|
ret = PTR_ERR(ctxt.handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto cleanup;
|
2008-08-18 03:11:00 -06:00
|
|
|
}
|
2008-11-11 17:27:01 -07:00
|
|
|
|
|
|
|
ret = __ocfs2_xattr_set_handle(inode, di, &xi, &xis, &xbs, &ctxt);
|
|
|
|
|
|
|
|
ocfs2_commit_trans(osb, ctxt.handle);
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
if (ctxt.data_ac)
|
|
|
|
ocfs2_free_alloc_context(ctxt.data_ac);
|
|
|
|
if (ctxt.meta_ac)
|
|
|
|
ocfs2_free_alloc_context(ctxt.meta_ac);
|
|
|
|
if (ocfs2_dealloc_has_cluster(&ctxt.dealloc))
|
|
|
|
ocfs2_schedule_truncate_log_flush(osb, 1);
|
|
|
|
ocfs2_run_deallocs(osb, &ctxt.dealloc);
|
2009-08-17 21:43:49 -06:00
|
|
|
|
2008-08-18 03:11:00 -06:00
|
|
|
cleanup:
|
2009-08-17 21:43:17 -06:00
|
|
|
if (ref_tree)
|
|
|
|
ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
|
2008-08-18 03:11:00 -06:00
|
|
|
up_write(&OCFS2_I(inode)->ip_xattr_sem);
|
2009-08-17 21:43:49 -06:00
|
|
|
if (!value && !ret) {
|
|
|
|
ret = ocfs2_try_remove_refcount_tree(inode, di_bh);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
}
|
2008-08-18 03:11:00 -06:00
|
|
|
ocfs2_inode_unlock(inode, 1);
|
2008-10-24 20:13:20 -06:00
|
|
|
cleanup_nolock:
|
2008-08-18 03:11:00 -06:00
|
|
|
brelse(di_bh);
|
|
|
|
brelse(xbs.xattr_bh);
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_free(xbs.bucket);
|
2008-08-18 03:11:00 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:38:50 -06:00
|
|
|
/*
|
|
|
|
* 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) {
|
2009-02-12 19:08:48 -07:00
|
|
|
ret = ocfs2_find_leaf(INODE_CACHE(inode), el, name_hash,
|
|
|
|
&eb_bh);
|
2008-08-18 03:38:50 -06:00
|
|
|
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);
|
|
|
|
|
2008-08-18 03:38:51 -06:00
|
|
|
static int ocfs2_find_xe_in_bucket(struct inode *inode,
|
2008-10-27 16:01:54 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
2008-08-18 03:38:51 -06:00
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
u32 name_hash,
|
|
|
|
u16 *xe_index,
|
|
|
|
int *found)
|
|
|
|
{
|
|
|
|
int i, ret = 0, cmp = 1, block_off, new_offset;
|
2008-10-27 16:01:54 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
2008-08-18 03:38:51 -06:00
|
|
|
size_t name_len = strlen(name);
|
|
|
|
struct ocfs2_xattr_entry *xe = NULL;
|
|
|
|
char *xe_name;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't use binary search in the bucket because there
|
|
|
|
* may be multiple entries with the same name hash.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
|
|
|
|
if (name_hash > le32_to_cpu(xe->xe_name_hash))
|
|
|
|
continue;
|
|
|
|
else if (name_hash < le32_to_cpu(xe->xe_name_hash))
|
|
|
|
break;
|
|
|
|
|
|
|
|
cmp = name_index - ocfs2_xattr_get_type(xe);
|
|
|
|
if (!cmp)
|
|
|
|
cmp = name_len - xe->xe_name_len;
|
|
|
|
if (cmp)
|
|
|
|
continue;
|
|
|
|
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
|
2008-08-18 03:38:51 -06:00
|
|
|
xh,
|
|
|
|
i,
|
|
|
|
&block_off,
|
|
|
|
&new_offset);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-11-13 15:49:19 -07:00
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
xe_name = bucket_block(bucket, block_off) + new_offset;
|
|
|
|
if (!memcmp(name, xe_name, name_len)) {
|
2008-08-18 03:38:51 -06:00
|
|
|
*xe_index = i;
|
|
|
|
*found = 1;
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the specified xattr entry in a series of buckets.
|
|
|
|
* This series start from p_blkno and last for num_clusters.
|
|
|
|
* The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
|
|
|
|
* the num of the valid buckets.
|
|
|
|
*
|
|
|
|
* Return the buffer_head this xattr should reside in. And if the xattr's
|
|
|
|
* hash is in the gap of 2 buckets, return the lower bucket.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret, found = 0;
|
|
|
|
struct ocfs2_xattr_header *xh = NULL;
|
|
|
|
struct ocfs2_xattr_entry *xe = NULL;
|
|
|
|
u16 index = 0;
|
|
|
|
u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
|
|
|
int low_bucket = 0, bucket, high_bucket;
|
2008-10-27 16:01:54 -06:00
|
|
|
struct ocfs2_xattr_bucket *search;
|
2008-08-18 03:38:51 -06:00
|
|
|
u32 last_hash;
|
2008-10-27 16:01:54 -06:00
|
|
|
u64 blkno, lower_blkno = 0;
|
2008-08-18 03:38:51 -06:00
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
search = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!search) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_read_xattr_bucket(search, p_blkno);
|
2008-08-18 03:38:51 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
xh = bucket_xh(search);
|
2008-08-18 03:38:51 -06:00
|
|
|
high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
|
|
|
|
while (low_bucket <= high_bucket) {
|
2008-10-27 16:01:54 -06:00
|
|
|
ocfs2_xattr_bucket_relse(search);
|
2008-08-18 03:38:51 -06:00
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
bucket = (low_bucket + high_bucket) / 2;
|
2008-08-18 03:38:51 -06:00
|
|
|
blkno = p_blkno + bucket * blk_per_bucket;
|
2008-10-27 16:01:54 -06:00
|
|
|
ret = ocfs2_read_xattr_bucket(search, blkno);
|
2008-08-18 03:38:51 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
xh = bucket_xh(search);
|
2008-08-18 03:38:51 -06:00
|
|
|
xe = &xh->xh_entries[0];
|
|
|
|
if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
|
|
|
|
high_bucket = bucket - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the hash of the last entry in our
|
2008-09-19 08:17:41 -06:00
|
|
|
* bucket is larger than the search one. for an empty
|
|
|
|
* bucket, the last one is also the first one.
|
2008-08-18 03:38:51 -06:00
|
|
|
*/
|
2008-09-19 08:17:41 -06:00
|
|
|
if (xh->xh_count)
|
|
|
|
xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1];
|
|
|
|
|
2008-08-18 03:38:51 -06:00
|
|
|
last_hash = le32_to_cpu(xe->xe_name_hash);
|
|
|
|
|
2008-10-27 16:01:54 -06:00
|
|
|
/* record lower_blkno which may be the insert place. */
|
|
|
|
lower_blkno = blkno;
|
2008-08-18 03:38:51 -06:00
|
|
|
|
|
|
|
if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
|
|
|
|
low_bucket = bucket + 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the searched xattr should reside in this bucket if exists. */
|
2008-10-27 16:01:54 -06:00
|
|
|
ret = ocfs2_find_xe_in_bucket(inode, search,
|
2008-08-18 03:38:51 -06:00
|
|
|
name_index, name, name_hash,
|
|
|
|
&index, &found);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Record the bucket we have found.
|
|
|
|
* When the xattr's hash value is in the gap of 2 buckets, we will
|
|
|
|
* always set it to the previous bucket.
|
|
|
|
*/
|
2008-10-27 16:01:54 -06:00
|
|
|
if (!lower_blkno)
|
|
|
|
lower_blkno = p_blkno;
|
|
|
|
|
|
|
|
/* This should be in cache - we just read it during the search */
|
|
|
|
ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
2008-08-18 03:38:51 -06:00
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->header = bucket_xh(xs->bucket);
|
|
|
|
xs->base = bucket_block(xs->bucket, 0);
|
2008-08-18 03:38:51 -06:00
|
|
|
xs->end = xs->base + inode->i_sb->s_blocksize;
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
xs->here = &xs->header->xh_entries[index];
|
|
|
|
mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name,
|
2008-10-24 20:13:20 -06:00
|
|
|
(unsigned long long)bucket_blkno(xs->bucket), index);
|
2008-08-18 03:38:51 -06:00
|
|
|
} else
|
|
|
|
ret = -ENODATA;
|
|
|
|
|
|
|
|
out:
|
2008-10-27 16:01:54 -06:00
|
|
|
ocfs2_xattr_bucket_free(search);
|
2008-08-18 03:38:51 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_index_block_find(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
int name_index,
|
|
|
|
const char *name,
|
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)root_bh->b_data;
|
|
|
|
struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
|
|
|
|
struct ocfs2_extent_list *el = &xb_root->xt_list;
|
|
|
|
u64 p_blkno = 0;
|
|
|
|
u32 first_hash, num_clusters = 0;
|
2008-10-09 09:06:13 -06:00
|
|
|
u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
|
2008-08-18 03:38:51 -06:00
|
|
|
|
|
|
|
if (le16_to_cpu(el->l_next_free_rec) == 0)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
|
|
|
|
name, name_hash, name_index);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash,
|
|
|
|
&num_clusters, el);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash);
|
|
|
|
|
|
|
|
mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
|
2008-10-29 15:45:30 -06:00
|
|
|
"in the rec is %u\n", num_clusters, (unsigned long long)p_blkno,
|
|
|
|
first_hash);
|
2008-08-18 03:38:51 -06:00
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash,
|
|
|
|
p_blkno, first_hash, num_clusters, xs);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-18 03:38:50 -06:00
|
|
|
static int ocfs2_iterate_xattr_buckets(struct inode *inode,
|
|
|
|
u64 blkno,
|
|
|
|
u32 clusters,
|
|
|
|
xattr_bucket_func *func,
|
|
|
|
void *para)
|
|
|
|
{
|
2008-10-24 18:16:48 -06:00
|
|
|
int i, ret = 0;
|
2008-08-18 03:38:50 -06:00
|
|
|
u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
|
|
|
|
u32 num_buckets = clusters * bpc;
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket;
|
2008-08-18 03:38:50 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!bucket) {
|
|
|
|
mlog_errno(-ENOMEM);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-08-18 03:38:50 -06:00
|
|
|
|
|
|
|
mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
|
2008-10-29 15:45:30 -06:00
|
|
|
clusters, (unsigned long long)blkno);
|
2008-08-18 03:38:50 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {
|
|
|
|
ret = ocfs2_read_xattr_bucket(bucket, blkno);
|
2008-08-18 03:38:50 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-10-24 20:13:20 -06:00
|
|
|
break;
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The real bucket num in this series of blocks is stored
|
|
|
|
* in the 1st bucket.
|
|
|
|
*/
|
|
|
|
if (i == 0)
|
2008-10-24 20:13:20 -06:00
|
|
|
num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);
|
2008-08-18 03:38:50 -06:00
|
|
|
|
2008-10-29 15:45:30 -06:00
|
|
|
mlog(0, "iterating xattr bucket %llu, first hash %u\n",
|
|
|
|
(unsigned long long)blkno,
|
2008-10-24 20:13:20 -06:00
|
|
|
le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));
|
2008-08-18 03:38:50 -06:00
|
|
|
if (func) {
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = func(inode, bucket, para);
|
2009-05-03 15:18:09 -06:00
|
|
|
if (ret && ret != -ERANGE)
|
2008-08-18 03:38:50 -06:00
|
|
|
mlog_errno(ret);
|
2008-10-24 20:13:20 -06:00
|
|
|
/* Fall through to bucket_relse() */
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_relse(bucket);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_free(bucket);
|
2008-08-18 03:38:50 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ocfs2_xattr_tree_list {
|
|
|
|
char *buffer;
|
|
|
|
size_t buffer_size;
|
2008-10-09 09:06:14 -06:00
|
|
|
size_t result;
|
2008-08-18 03:38:50 -06:00
|
|
|
};
|
|
|
|
|
2009-08-17 21:43:21 -06:00
|
|
|
static int ocfs2_xattr_bucket_get_name_value(struct super_block *sb,
|
2008-08-18 03:38:50 -06:00
|
|
|
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);
|
|
|
|
|
2009-08-17 21:43:21 -06:00
|
|
|
*block_off = name_offset >> sb->s_blocksize_bits;
|
|
|
|
*new_offset = name_offset % sb->s_blocksize;
|
2008-08-18 03:38:50 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_list_xattr_bucket(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
void *para)
|
|
|
|
{
|
2008-10-09 09:06:14 -06:00
|
|
|
int ret = 0, type;
|
2008-08-18 03:38:50 -06:00
|
|
|
struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
|
|
|
|
int i, block_off, new_offset;
|
2008-10-09 09:06:14 -06:00
|
|
|
const char *prefix, *name;
|
2008-08-18 03:38:50 -06:00
|
|
|
|
2008-10-24 18:04:49 -06:00
|
|
|
for (i = 0 ; i < le16_to_cpu(bucket_xh(bucket)->xh_count); i++) {
|
|
|
|
struct ocfs2_xattr_entry *entry = &bucket_xh(bucket)->xh_entries[i];
|
2008-10-09 09:06:14 -06:00
|
|
|
type = ocfs2_xattr_get_type(entry);
|
|
|
|
prefix = ocfs2_xattr_prefix(type);
|
2008-08-18 03:38:50 -06:00
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
if (prefix) {
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
|
2008-10-24 18:04:49 -06:00
|
|
|
bucket_xh(bucket),
|
2008-08-18 03:38:50 -06:00
|
|
|
i,
|
|
|
|
&block_off,
|
|
|
|
&new_offset);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2008-10-09 09:06:14 -06:00
|
|
|
|
2008-10-24 17:57:21 -06:00
|
|
|
name = (const char *)bucket_block(bucket, block_off) +
|
2008-10-09 09:06:14 -06:00
|
|
|
new_offset;
|
|
|
|
ret = ocfs2_xattr_list_entry(xl->buffer,
|
|
|
|
xl->buffer_size,
|
|
|
|
&xl->result,
|
|
|
|
prefix, name,
|
|
|
|
entry->xe_name_len);
|
|
|
|
if (ret)
|
|
|
|
break;
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
static int ocfs2_iterate_xattr_index_block(struct inode *inode,
|
|
|
|
struct buffer_head *blk_bh,
|
|
|
|
xattr_tree_rec_func *rec_func,
|
|
|
|
void *para)
|
2008-08-18 03:38:50 -06:00
|
|
|
{
|
2009-08-17 21:43:42 -06:00
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)blk_bh->b_data;
|
|
|
|
struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
|
2008-08-18 03:38:50 -06:00
|
|
|
int ret = 0;
|
|
|
|
u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
|
|
|
|
u64 p_blkno = 0;
|
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
if (!el->l_next_free_rec || !rec_func)
|
2008-08-18 03:38:50 -06:00
|
|
|
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);
|
2009-08-17 21:43:42 -06:00
|
|
|
break;
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
ret = rec_func(inode, blk_bh, p_blkno, e_cpos,
|
|
|
|
num_clusters, para);
|
2008-08-18 03:38:50 -06:00
|
|
|
if (ret) {
|
2009-05-03 15:18:09 -06:00
|
|
|
if (ret != -ERANGE)
|
|
|
|
mlog_errno(ret);
|
2009-08-17 21:43:42 -06:00
|
|
|
break;
|
2008-08-18 03:38:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (e_cpos == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
name_hash = e_cpos - 1;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_list_xattr_tree_rec(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno, u32 cpos, u32 len, void *para)
|
|
|
|
{
|
|
|
|
return ocfs2_iterate_xattr_buckets(inode, blkno, len,
|
|
|
|
ocfs2_list_xattr_bucket, para);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
|
|
|
|
struct buffer_head *blk_bh,
|
|
|
|
char *buffer,
|
|
|
|
size_t buffer_size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_xattr_tree_list xl = {
|
|
|
|
.buffer = buffer,
|
|
|
|
.buffer_size = buffer_size,
|
|
|
|
.result = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
|
|
|
|
ocfs2_list_xattr_tree_rec, &xl);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-10-09 09:06:14 -06:00
|
|
|
ret = xl.result;
|
2008-08-18 03:38:50 -06:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
static int cmp_xe(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct ocfs2_xattr_entry *l = a, *r = b;
|
|
|
|
u32 l_hash = le32_to_cpu(l->xe_name_hash);
|
|
|
|
u32 r_hash = le32_to_cpu(r->xe_name_hash);
|
|
|
|
|
|
|
|
if (l_hash > r_hash)
|
|
|
|
return 1;
|
|
|
|
if (l_hash < r_hash)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void swap_xe(void *a, void *b, int size)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *l = a, *r = b, tmp;
|
|
|
|
|
|
|
|
tmp = *l;
|
|
|
|
memcpy(l, r, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When the ocfs2_xattr_block is filled up, new bucket will be created
|
|
|
|
* and all the xattr entries will be moved to the new bucket.
|
2008-10-27 16:18:29 -06:00
|
|
|
* The header goes at the start of the bucket, and the names+values are
|
|
|
|
* filled from the end. This is why *target starts as the last buffer.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
* Note: we need to sort the entries since they are not saved in order
|
|
|
|
* in the ocfs2_xattr_block.
|
|
|
|
*/
|
|
|
|
static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
|
|
|
|
struct buffer_head *xb_bh,
|
2008-10-27 16:18:29 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int i, blocksize = inode->i_sb->s_blocksize;
|
2008-10-27 16:18:29 -06:00
|
|
|
int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u16 offset, size, off_change;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)xb_bh->b_data;
|
|
|
|
struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header;
|
2008-10-27 16:18:29 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u16 count = le16_to_cpu(xb_xh->xh_count);
|
2008-10-27 16:18:29 -06:00
|
|
|
char *src = xb_bh->b_data;
|
|
|
|
char *target = bucket_block(bucket, blks - 1);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog(0, "cp xattr from block %llu to bucket %llu\n",
|
|
|
|
(unsigned long long)xb_bh->b_blocknr,
|
2008-10-27 16:18:29 -06:00
|
|
|
(unsigned long long)bucket_blkno(bucket));
|
|
|
|
|
|
|
|
for (i = 0; i < blks; i++)
|
|
|
|
memset(bucket_block(bucket, i), 0, blocksize);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since the xe_name_offset is based on ocfs2_xattr_header,
|
|
|
|
* there is a offset change corresponding to the change of
|
|
|
|
* ocfs2_xattr_header's position.
|
|
|
|
*/
|
|
|
|
off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
|
|
|
|
xe = &xb_xh->xh_entries[count - 1];
|
|
|
|
offset = le16_to_cpu(xe->xe_name_offset) + off_change;
|
|
|
|
size = blocksize - offset;
|
|
|
|
|
|
|
|
/* copy all the names and values. */
|
|
|
|
memcpy(target + offset, src + offset, size);
|
|
|
|
|
|
|
|
/* Init new header now. */
|
|
|
|
xh->xh_count = xb_xh->xh_count;
|
|
|
|
xh->xh_num_buckets = cpu_to_le16(1);
|
|
|
|
xh->xh_name_value_len = cpu_to_le16(size);
|
|
|
|
xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size);
|
|
|
|
|
|
|
|
/* copy all the entries. */
|
2008-10-27 16:18:29 -06:00
|
|
|
target = bucket_block(bucket, 0);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
offset = offsetof(struct ocfs2_xattr_header, xh_entries);
|
|
|
|
size = count * sizeof(struct ocfs2_xattr_entry);
|
|
|
|
memcpy(target + offset, (char *)xb_xh + offset, size);
|
|
|
|
|
|
|
|
/* Change the xe offset for all the xe because of the move. */
|
|
|
|
off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize +
|
|
|
|
offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change);
|
|
|
|
|
|
|
|
mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n",
|
|
|
|
offset, size, off_change);
|
|
|
|
|
|
|
|
sort(target + offset, count, sizeof(struct ocfs2_xattr_entry),
|
|
|
|
cmp_xe, swap_xe);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After we move xattr from block to index btree, we have to
|
|
|
|
* update ocfs2_xattr_search to the new xe and base.
|
|
|
|
*
|
|
|
|
* When the entry is in xattr block, xattr_bh indicates the storage place.
|
|
|
|
* While if the entry is in index b-tree, "bucket" indicates the
|
|
|
|
* real place of the xattr.
|
|
|
|
*/
|
2008-10-27 16:18:29 -06:00
|
|
|
static void ocfs2_xattr_update_xattr_search(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct buffer_head *old_bh)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
char *buf = old_bh->b_data;
|
|
|
|
struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf;
|
|
|
|
struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header;
|
2008-10-27 16:18:29 -06:00
|
|
|
int i;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->header = bucket_xh(xs->bucket);
|
2008-10-27 16:18:29 -06:00
|
|
|
xs->base = bucket_block(xs->bucket, 0);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
xs->end = xs->base + inode->i_sb->s_blocksize;
|
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
if (xs->not_found)
|
|
|
|
return;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
i = xs->here - old_xh->xh_entries;
|
|
|
|
xs->here = &xs->header->xh_entries[i];
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_create_index_block(struct inode *inode,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
2008-11-11 17:27:01 -07:00
|
|
|
int ret;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u32 bit_off, len;
|
|
|
|
u64 blkno;
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct buffer_head *xb_bh = xs->xattr_bh;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)xb_bh->b_data;
|
|
|
|
struct ocfs2_xattr_tree_root *xr;
|
|
|
|
u16 xb_flags = le16_to_cpu(xb->xb_flags);
|
|
|
|
|
|
|
|
mlog(0, "create xattr index block for %llu\n",
|
|
|
|
(unsigned long long)xb_bh->b_blocknr);
|
|
|
|
|
|
|
|
BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
|
2008-10-27 16:18:29 -06:00
|
|
|
BUG_ON(!xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX:
|
|
|
|
* We can use this lock for now, and maybe move to a dedicated mutex
|
|
|
|
* if performance becomes a problem later.
|
|
|
|
*/
|
|
|
|
down_write(&oi->ip_alloc_sem);
|
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), xb_bh,
|
2008-12-09 17:11:49 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac,
|
|
|
|
1, 1, &bit_off, &len);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The bucket may spread in many blocks, and
|
|
|
|
* we will only touch the 1st block and the last block
|
|
|
|
* in the whole bucket(one for entry and one for data).
|
|
|
|
*/
|
|
|
|
blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
|
|
|
|
|
2008-10-29 15:45:30 -06:00
|
|
|
mlog(0, "allocate 1 cluster from %llu to xattr block\n",
|
|
|
|
(unsigned long long)blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
ret = ocfs2_init_xattr_bucket(xs->bucket, blkno);
|
|
|
|
if (ret) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-27 16:18:29 -06:00
|
|
|
ocfs2_xattr_update_xattr_search(inode, xs, xb_bh);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
|
|
|
|
memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
|
|
|
|
offsetof(struct ocfs2_xattr_block, xb_attrs));
|
|
|
|
|
|
|
|
xr = &xb->xb_attrs.xb_root;
|
|
|
|
xr->xt_clusters = cpu_to_le32(1);
|
|
|
|
xr->xt_last_eb_blk = 0;
|
|
|
|
xr->xt_list.l_tree_depth = 0;
|
|
|
|
xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb));
|
|
|
|
xr->xt_list.l_next_free_rec = cpu_to_le16(1);
|
|
|
|
|
|
|
|
xr->xt_list.l_recs[0].e_cpos = 0;
|
|
|
|
xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
|
|
|
|
xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
|
|
|
|
|
|
|
|
xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED);
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
ocfs2_journal_dirty(handle, xb_bh);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
out:
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
up_write(&oi->ip_alloc_sem);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmp_xe_offset(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct ocfs2_xattr_entry *l = a, *r = b;
|
|
|
|
u32 l_name_offset = le16_to_cpu(l->xe_name_offset);
|
|
|
|
u32 r_name_offset = le16_to_cpu(r->xe_name_offset);
|
|
|
|
|
|
|
|
if (l_name_offset < r_name_offset)
|
|
|
|
return 1;
|
|
|
|
if (l_name_offset > r_name_offset)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* defrag a xattr bucket if we find that the bucket has some
|
|
|
|
* holes beteen name/value pairs.
|
|
|
|
* We will move all the name/value pairs to the end of the bucket
|
|
|
|
* so that we can spare some space for insertion.
|
|
|
|
*/
|
|
|
|
static int ocfs2_defrag_xattr_bucket(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket)
|
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
size_t end, offset, len, value_len;
|
|
|
|
struct ocfs2_xattr_header *xh;
|
|
|
|
char *entries, *buf, *bucket_buf = NULL;
|
2008-10-24 17:21:03 -06:00
|
|
|
u64 blkno = bucket_blkno(bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u16 xh_free_start;
|
|
|
|
size_t blocksize = inode->i_sb->s_blocksize;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In order to make the operation more efficient and generic,
|
|
|
|
* we copy all the blocks into a contiguous memory and do the
|
|
|
|
* defragment there, so if anything is error, we will not touch
|
|
|
|
* the real block.
|
|
|
|
*/
|
|
|
|
bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS);
|
|
|
|
if (!bucket_buf) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf = bucket_buf;
|
2008-11-05 17:10:47 -07:00
|
|
|
for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
|
|
|
|
memcpy(buf, bucket_block(bucket, i), blocksize);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-05 17:10:47 -07:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
|
2008-10-27 16:25:18 -06:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xh = (struct ocfs2_xattr_header *)bucket_buf;
|
|
|
|
entries = (char *)xh->xh_entries;
|
|
|
|
xh_free_start = le16_to_cpu(xh->xh_free_start);
|
|
|
|
|
|
|
|
mlog(0, "adjust xattr bucket in %llu, count = %u, "
|
|
|
|
"xh_free_start = %u, xh_name_value_len = %u.\n",
|
2008-10-29 15:45:30 -06:00
|
|
|
(unsigned long long)blkno, le16_to_cpu(xh->xh_count),
|
|
|
|
xh_free_start, le16_to_cpu(xh->xh_name_value_len));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* sort all the entries by their offset.
|
|
|
|
* the largest will be the first, so that we can
|
|
|
|
* move them to the end one by one.
|
|
|
|
*/
|
|
|
|
sort(entries, le16_to_cpu(xh->xh_count),
|
|
|
|
sizeof(struct ocfs2_xattr_entry),
|
|
|
|
cmp_xe_offset, swap_xe);
|
|
|
|
|
|
|
|
/* Move all name/values to the end of the bucket. */
|
|
|
|
xe = xh->xh_entries;
|
|
|
|
end = OCFS2_XATTR_BUCKET_SIZE;
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) {
|
|
|
|
offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
value_len = OCFS2_XATTR_SIZE(
|
|
|
|
le64_to_cpu(xe->xe_value_size));
|
|
|
|
else
|
|
|
|
value_len = OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
len = OCFS2_XATTR_SIZE(xe->xe_name_len) + value_len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We must make sure that the name/value pair
|
|
|
|
* exist in the same block. So adjust end to
|
|
|
|
* the previous block end if needed.
|
|
|
|
*/
|
|
|
|
if (((end - len) / blocksize !=
|
|
|
|
(end - 1) / blocksize))
|
|
|
|
end = end - end % blocksize;
|
|
|
|
|
|
|
|
if (end > offset + len) {
|
|
|
|
memmove(bucket_buf + end - len,
|
|
|
|
bucket_buf + offset, len);
|
|
|
|
xe->xe_name_offset = cpu_to_le16(end - len);
|
|
|
|
}
|
|
|
|
|
|
|
|
mlog_bug_on_msg(end < offset + len, "Defrag check failed for "
|
|
|
|
"bucket %llu\n", (unsigned long long)blkno);
|
|
|
|
|
|
|
|
end -= len;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for "
|
|
|
|
"bucket %llu\n", (unsigned long long)blkno);
|
|
|
|
|
|
|
|
if (xh_free_start == end)
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
memset(bucket_buf + xh_free_start, 0, end - xh_free_start);
|
|
|
|
xh->xh_free_start = cpu_to_le16(end);
|
|
|
|
|
|
|
|
/* sort the entries by their name_hash. */
|
|
|
|
sort(entries, le16_to_cpu(xh->xh_count),
|
|
|
|
sizeof(struct ocfs2_xattr_entry),
|
|
|
|
cmp_xe, swap_xe);
|
|
|
|
|
|
|
|
buf = bucket_buf;
|
2008-11-05 17:10:47 -07:00
|
|
|
for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)
|
|
|
|
memcpy(bucket_block(bucket, i), buf, blocksize);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(bucket_buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-25 20:58:16 -07:00
|
|
|
* prev_blkno points to the start of an existing extent. new_blkno
|
|
|
|
* points to a newly allocated extent. Because we know each of our
|
|
|
|
* clusters contains more than bucket, we can easily split one cluster
|
|
|
|
* at a bucket boundary. So we take the last cluster of the existing
|
|
|
|
* extent and split it down the middle. We move the last half of the
|
|
|
|
* buckets in the last cluster of the existing extent over to the new
|
|
|
|
* extent.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*
|
2008-11-25 20:58:16 -07:00
|
|
|
* first_bh is the buffer at prev_blkno so we can update the existing
|
|
|
|
* extent's bucket count. header_bh is the bucket were we were hoping
|
|
|
|
* to insert our xattr. If the bucket move places the target in the new
|
|
|
|
* extent, we'll update first_bh and header_bh after modifying the old
|
|
|
|
* extent.
|
|
|
|
*
|
|
|
|
* first_hash will be set as the 1st xe's name_hash in the new extent.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
|
|
|
static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode,
|
|
|
|
handle_t *handle,
|
2008-11-26 15:25:21 -07:00
|
|
|
struct ocfs2_xattr_bucket *first,
|
|
|
|
struct ocfs2_xattr_bucket *target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u64 new_blkno,
|
|
|
|
u32 num_clusters,
|
|
|
|
u32 *first_hash)
|
|
|
|
{
|
2008-11-26 14:36:24 -07:00
|
|
|
int ret;
|
2008-11-26 15:25:21 -07:00
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(sb);
|
|
|
|
int num_buckets = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
|
2008-11-25 20:58:16 -07:00
|
|
|
int to_move = num_buckets / 2;
|
2008-11-26 14:36:24 -07:00
|
|
|
u64 src_blkno;
|
2008-11-26 15:25:21 -07:00
|
|
|
u64 last_cluster_blkno = bucket_blkno(first) +
|
|
|
|
((num_clusters - 1) * ocfs2_clusters_to_blocks(sb, 1));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 15:25:21 -07:00
|
|
|
BUG_ON(le16_to_cpu(bucket_xh(first)->xh_num_buckets) < num_buckets);
|
|
|
|
BUG_ON(OCFS2_XATTR_BUCKET_SIZE == OCFS2_SB(sb)->s_clustersize);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog(0, "move half of xattrs in cluster %llu to %llu\n",
|
2008-11-26 14:36:24 -07:00
|
|
|
(unsigned long long)last_cluster_blkno, (unsigned long long)new_blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 15:25:21 -07:00
|
|
|
ret = ocfs2_mv_xattr_buckets(inode, handle, bucket_blkno(first),
|
2008-11-26 14:36:24 -07:00
|
|
|
last_cluster_blkno, new_blkno,
|
|
|
|
to_move, first_hash);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-26 14:36:24 -07:00
|
|
|
/* This is the first bucket that got moved */
|
|
|
|
src_blkno = last_cluster_blkno + (to_move * blks_per_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 20:58:16 -07:00
|
|
|
/*
|
2008-11-26 14:36:24 -07:00
|
|
|
* If the target bucket was part of the moved buckets, we need to
|
2008-11-26 15:25:21 -07:00
|
|
|
* update first and target.
|
2008-11-25 20:58:16 -07:00
|
|
|
*/
|
2008-11-26 15:25:21 -07:00
|
|
|
if (bucket_blkno(target) >= src_blkno) {
|
2008-11-25 20:58:16 -07:00
|
|
|
/* Find the block for the new target bucket */
|
|
|
|
src_blkno = new_blkno +
|
2008-11-26 15:25:21 -07:00
|
|
|
(bucket_blkno(target) - src_blkno);
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_relse(first);
|
|
|
|
ocfs2_xattr_bucket_relse(target);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 20:58:16 -07:00
|
|
|
/*
|
2008-11-26 14:36:24 -07:00
|
|
|
* These shouldn't fail - the buffers are in the
|
2008-11-25 20:58:16 -07:00
|
|
|
* journal from ocfs2_cp_xattr_bucket().
|
|
|
|
*/
|
2008-11-26 15:25:21 -07:00
|
|
|
ret = ocfs2_read_xattr_bucket(first, new_blkno);
|
2008-11-26 14:36:24 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-26 15:25:21 -07:00
|
|
|
ret = ocfs2_read_xattr_bucket(target, src_blkno);
|
|
|
|
if (ret)
|
2008-11-25 20:58:16 -07:00
|
|
|
mlog_errno(ret);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-10-26 16:06:24 -06:00
|
|
|
* Find the suitable pos when we divide a bucket into 2.
|
|
|
|
* We have to make sure the xattrs with the same hash value exist
|
|
|
|
* in the same bucket.
|
|
|
|
*
|
|
|
|
* If this ocfs2_xattr_header covers more than one hash value, find a
|
|
|
|
* place where the hash value changes. Try to find the most even split.
|
|
|
|
* The most common case is that all entries have different hash values,
|
|
|
|
* and the first check we make will find a place to split.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_find_divide_pos(struct ocfs2_xattr_header *xh)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *entries = xh->xh_entries;
|
|
|
|
int count = le16_to_cpu(xh->xh_count);
|
|
|
|
int delta, middle = count / 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We start at the middle. Each step gets farther away in both
|
|
|
|
* directions. We therefore hit the change in hash value
|
|
|
|
* nearest to the middle. Note that this loop does not execute for
|
|
|
|
* count < 2.
|
|
|
|
*/
|
|
|
|
for (delta = 0; delta < middle; delta++) {
|
|
|
|
/* Let's check delta earlier than middle */
|
|
|
|
if (cmp_xe(&entries[middle - delta - 1],
|
|
|
|
&entries[middle - delta]))
|
|
|
|
return middle - delta;
|
|
|
|
|
|
|
|
/* For even counts, don't walk off the end */
|
|
|
|
if ((middle + delta + 1) == count)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Now try delta past middle */
|
|
|
|
if (cmp_xe(&entries[middle + delta],
|
|
|
|
&entries[middle + delta + 1]))
|
|
|
|
return middle + delta + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Every entry had the same hash */
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move some xattrs in old bucket(blk) to new bucket(new_blk).
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
* first_hash will record the 1st hash of the new bucket.
|
2008-10-26 16:06:24 -06:00
|
|
|
*
|
|
|
|
* Normally half of the xattrs will be moved. But we have to make
|
|
|
|
* sure that the xattrs with the same hash value are stored in the
|
|
|
|
* same bucket. If all the xattrs in this bucket have the same hash
|
|
|
|
* value, the new bucket will be initialized as an empty one and the
|
|
|
|
* first_hash will be initialized as (hash_value+1).
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
2008-10-26 16:06:24 -06:00
|
|
|
static int ocfs2_divide_xattr_bucket(struct inode *inode,
|
|
|
|
handle_t *handle,
|
|
|
|
u64 blk,
|
|
|
|
u64 new_blk,
|
|
|
|
u32 *first_hash,
|
|
|
|
int new_bucket_head)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int ret, i;
|
2008-10-26 16:06:24 -06:00
|
|
|
int count, start, len, name_value_len = 0, xe_len, name_offset = 0;
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_header *xh;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
int blocksize = inode->i_sb->s_blocksize;
|
|
|
|
|
2008-10-26 16:06:24 -06:00
|
|
|
mlog(0, "move some of xattrs from bucket %llu to %llu\n",
|
2008-10-29 15:45:30 -06:00
|
|
|
(unsigned long long)blk, (unsigned long long)new_blk);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
s_bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
t_bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!s_bucket || !t_bucket) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_read_xattr_bucket(s_bucket, blk);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, s_bucket,
|
2008-10-24 19:47:33 -06:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-10-24 18:33:40 -06:00
|
|
|
/*
|
|
|
|
* Even if !new_bucket_head, we're overwriting t_bucket. Thus,
|
|
|
|
* there's no need to read it.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_init_xattr_bucket(t_bucket, new_blk);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-25 20:00:15 -07:00
|
|
|
/*
|
|
|
|
* Hey, if we're overwriting t_bucket, what difference does
|
|
|
|
* ACCESS_CREATE vs ACCESS_WRITE make? See the comment in the
|
|
|
|
* same part of ocfs2_cp_xattr_bucket().
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
|
2008-10-24 19:47:33 -06:00
|
|
|
new_bucket_head ?
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE :
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xh = bucket_xh(s_bucket);
|
2008-10-26 16:06:24 -06:00
|
|
|
count = le16_to_cpu(xh->xh_count);
|
|
|
|
start = ocfs2_xattr_find_divide_pos(xh);
|
|
|
|
|
|
|
|
if (start == count) {
|
|
|
|
xe = &xh->xh_entries[start-1];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* initialized a new empty bucket here.
|
|
|
|
* The hash value is set as one larger than
|
|
|
|
* that of the last entry in the previous bucket.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
for (i = 0; i < t_bucket->bu_blocks; i++)
|
|
|
|
memset(bucket_block(t_bucket, i), 0, blocksize);
|
2008-10-26 16:06:24 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xh = bucket_xh(t_bucket);
|
2008-10-26 16:06:24 -06:00
|
|
|
xh->xh_free_start = cpu_to_le16(blocksize);
|
|
|
|
xh->xh_entries[0].xe_name_hash = xe->xe_name_hash;
|
|
|
|
le32_add_cpu(&xh->xh_entries[0].xe_name_hash, 1);
|
|
|
|
|
|
|
|
goto set_num_buckets;
|
|
|
|
}
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
/* copy the whole bucket to the new first. */
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/* update the new bucket. */
|
2008-10-24 20:13:20 -06:00
|
|
|
xh = bucket_xh(t_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the total name/value len and xh_free_start for
|
|
|
|
* the old bucket first.
|
|
|
|
*/
|
|
|
|
name_offset = OCFS2_XATTR_BUCKET_SIZE;
|
|
|
|
name_value_len = 0;
|
|
|
|
for (i = 0; i < start; i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
xe_len +=
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
|
|
|
|
else
|
|
|
|
xe_len += OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
name_value_len += xe_len;
|
|
|
|
if (le16_to_cpu(xe->xe_name_offset) < name_offset)
|
|
|
|
name_offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now begin the modification to the new bucket.
|
|
|
|
*
|
|
|
|
* In the new bucket, We just move the xattr entry to the beginning
|
|
|
|
* and don't touch the name/value. So there will be some holes in the
|
|
|
|
* bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
|
|
|
|
* called.
|
|
|
|
*/
|
|
|
|
xe = &xh->xh_entries[start];
|
|
|
|
len = sizeof(struct ocfs2_xattr_entry) * (count - start);
|
|
|
|
mlog(0, "mv xattr entry len %d from %d to %d\n", len,
|
2008-08-19 11:54:29 -06:00
|
|
|
(int)((char *)xe - (char *)xh),
|
|
|
|
(int)((char *)xh->xh_entries - (char *)xh));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
memmove((char *)xh->xh_entries, (char *)xe, len);
|
|
|
|
xe = &xh->xh_entries[count - start];
|
|
|
|
len = sizeof(struct ocfs2_xattr_entry) * start;
|
|
|
|
memset((char *)xe, 0, len);
|
|
|
|
|
|
|
|
le16_add_cpu(&xh->xh_count, -start);
|
|
|
|
le16_add_cpu(&xh->xh_name_value_len, -name_value_len);
|
|
|
|
|
|
|
|
/* Calculate xh_free_start for the new bucket. */
|
|
|
|
xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
xe_len +=
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
|
|
|
|
else
|
|
|
|
xe_len += OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
if (le16_to_cpu(xe->xe_name_offset) <
|
|
|
|
le16_to_cpu(xh->xh_free_start))
|
|
|
|
xh->xh_free_start = xe->xe_name_offset;
|
|
|
|
}
|
|
|
|
|
2008-10-26 16:06:24 -06:00
|
|
|
set_num_buckets:
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
/* set xh->xh_num_buckets for the new xh. */
|
|
|
|
if (new_bucket_head)
|
|
|
|
xh->xh_num_buckets = cpu_to_le16(1);
|
|
|
|
else
|
|
|
|
xh->xh_num_buckets = 0;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/* store the first_hash of the new bucket. */
|
|
|
|
if (first_hash)
|
|
|
|
*first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
|
|
|
|
|
|
|
|
/*
|
2008-10-26 16:06:24 -06:00
|
|
|
* Now only update the 1st block of the old bucket. If we
|
|
|
|
* just added a new empty bucket, there is no need to modify
|
|
|
|
* it.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
2008-10-26 16:06:24 -06:00
|
|
|
if (start == count)
|
|
|
|
goto out;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
xh = bucket_xh(s_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
memset(&xh->xh_entries[start], 0,
|
|
|
|
sizeof(struct ocfs2_xattr_entry) * (count - start));
|
|
|
|
xh->xh_count = cpu_to_le16(start);
|
|
|
|
xh->xh_free_start = cpu_to_le16(name_offset);
|
|
|
|
xh->xh_name_value_len = cpu_to_le16(name_value_len);
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, s_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
out:
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_free(s_bucket);
|
|
|
|
ocfs2_xattr_bucket_free(t_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy xattr from one bucket to another bucket.
|
|
|
|
*
|
|
|
|
* The caller must make sure that the journal transaction
|
|
|
|
* has enough space for journaling.
|
|
|
|
*/
|
|
|
|
static int ocfs2_cp_xattr_bucket(struct inode *inode,
|
|
|
|
handle_t *handle,
|
|
|
|
u64 s_blkno,
|
|
|
|
u64 t_blkno,
|
|
|
|
int t_is_new)
|
|
|
|
{
|
2008-10-24 19:54:43 -06:00
|
|
|
int ret;
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_bucket *s_bucket = NULL, *t_bucket = NULL;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
BUG_ON(s_blkno == t_blkno);
|
|
|
|
|
|
|
|
mlog(0, "cp bucket %llu to %llu, target is %d\n",
|
2008-10-29 15:45:30 -06:00
|
|
|
(unsigned long long)s_blkno, (unsigned long long)t_blkno,
|
|
|
|
t_is_new);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
s_bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
t_bucket = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!s_bucket || !t_bucket) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-25 18:06:40 -07:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_read_xattr_bucket(s_bucket, s_blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2008-10-24 18:33:40 -06:00
|
|
|
/*
|
|
|
|
* Even if !t_is_new, we're overwriting t_bucket. Thus,
|
|
|
|
* there's no need to read it.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_init_xattr_bucket(t_bucket, t_blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2008-11-25 20:00:15 -07:00
|
|
|
/*
|
|
|
|
* Hey, if we're overwriting t_bucket, what difference does
|
|
|
|
* ACCESS_CREATE vs ACCESS_WRITE make? Well, if we allocated a new
|
2008-11-26 14:02:18 -07:00
|
|
|
* cluster to fill, we came here from
|
|
|
|
* ocfs2_mv_xattr_buckets(), and it is really new -
|
|
|
|
* ACCESS_CREATE is required. But we also might have moved data
|
|
|
|
* out of t_bucket before extending back into it.
|
|
|
|
* ocfs2_add_new_xattr_bucket() can do this - its call to
|
|
|
|
* ocfs2_add_new_xattr_cluster() may have created a new extent
|
2008-11-25 20:00:15 -07:00
|
|
|
* and copied out the end of the old extent. Then it re-extends
|
|
|
|
* the old extent back to create space for new xattrs. That's
|
|
|
|
* how we get here, and the bucket isn't really new.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, t_bucket,
|
2008-10-24 19:47:33 -06:00
|
|
|
t_is_new ?
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE :
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_copy_data(t_bucket, s_bucket);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, t_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
out:
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_free(t_bucket);
|
|
|
|
ocfs2_xattr_bucket_free(s_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-26 14:02:18 -07:00
|
|
|
* src_blk points to the start of an existing extent. last_blk points to
|
|
|
|
* last cluster in that extent. to_blk points to a newly allocated
|
2008-11-26 14:18:31 -07:00
|
|
|
* extent. We copy the buckets from the cluster at last_blk to the new
|
|
|
|
* extent. If start_bucket is non-zero, we skip that many buckets before
|
|
|
|
* we start copying. The new extent's xh_num_buckets gets set to the
|
|
|
|
* number of buckets we copied. The old extent's xh_num_buckets shrinks
|
|
|
|
* by the same amount.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
2008-11-26 14:18:31 -07:00
|
|
|
static int 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)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int i, ret, credits;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
2008-11-25 19:36:42 -07:00
|
|
|
int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
|
2008-11-25 19:36:42 -07:00
|
|
|
struct ocfs2_xattr_bucket *old_first, *new_first;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 14:02:18 -07:00
|
|
|
mlog(0, "mv xattrs from cluster %llu to %llu\n",
|
|
|
|
(unsigned long long)last_blk, (unsigned long long)to_blk);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 14:18:31 -07:00
|
|
|
BUG_ON(start_bucket >= num_buckets);
|
|
|
|
if (start_bucket) {
|
|
|
|
num_buckets -= start_bucket;
|
|
|
|
last_blk += (start_bucket * blks_per_bucket);
|
|
|
|
}
|
|
|
|
|
2008-11-25 19:36:42 -07:00
|
|
|
/* The first bucket of the original extent */
|
|
|
|
old_first = ocfs2_xattr_bucket_new(inode);
|
|
|
|
/* The first bucket of the new extent */
|
|
|
|
new_first = ocfs2_xattr_bucket_new(inode);
|
|
|
|
if (!old_first || !new_first) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-26 14:02:18 -07:00
|
|
|
ret = ocfs2_read_xattr_bucket(old_first, src_blk);
|
2008-11-25 19:36:42 -07:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
/*
|
2008-11-26 14:18:31 -07:00
|
|
|
* We need to update the first bucket of the old extent and all
|
|
|
|
* the buckets going to the new extent.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
2008-11-26 14:18:31 -07:00
|
|
|
credits = ((num_buckets + 1) * blks_per_bucket) +
|
|
|
|
handle->h_buffer_credits;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_extend_trans(handle, credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-25 19:36:42 -07:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, old_first,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_buckets; i++) {
|
|
|
|
ret = ocfs2_cp_xattr_bucket(inode, handle,
|
2008-11-26 14:02:18 -07:00
|
|
|
last_blk + (i * blks_per_bucket),
|
2008-11-25 19:36:42 -07:00
|
|
|
to_blk + (i * blks_per_bucket),
|
|
|
|
1);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-25 19:36:42 -07:00
|
|
|
/*
|
|
|
|
* Get the new bucket ready before we dirty anything
|
|
|
|
* (This actually shouldn't fail, because we already dirtied
|
|
|
|
* it once in ocfs2_cp_xattr_bucket()).
|
|
|
|
*/
|
|
|
|
ret = ocfs2_read_xattr_bucket(new_first, to_blk);
|
|
|
|
if (ret) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-25 19:36:42 -07:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, new_first,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-25 19:36:42 -07:00
|
|
|
/* Now update the headers */
|
|
|
|
le16_add_cpu(&bucket_xh(old_first)->xh_num_buckets, -num_buckets);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, old_first);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 19:36:42 -07:00
|
|
|
bucket_xh(new_first)->xh_num_buckets = cpu_to_le16(num_buckets);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, new_first);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
if (first_hash)
|
2008-11-25 19:36:42 -07:00
|
|
|
*first_hash = le32_to_cpu(bucket_xh(new_first)->xh_entries[0].xe_name_hash);
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
out:
|
2008-11-25 19:36:42 -07:00
|
|
|
ocfs2_xattr_bucket_free(new_first);
|
|
|
|
ocfs2_xattr_bucket_free(old_first);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-10-26 16:06:24 -06:00
|
|
|
* Move some xattrs in this cluster to the new cluster.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
* This function should only be called when bucket size == cluster size.
|
|
|
|
* Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
|
|
|
|
*/
|
2008-10-26 16:06:24 -06:00
|
|
|
static int ocfs2_divide_xattr_cluster(struct inode *inode,
|
|
|
|
handle_t *handle,
|
|
|
|
u64 prev_blk,
|
|
|
|
u64 new_blk,
|
|
|
|
u32 *first_hash)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2008-11-11 17:27:01 -07:00
|
|
|
int ret, credits = 2 * blk_per_bucket + handle->h_buffer_credits;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize);
|
|
|
|
|
|
|
|
ret = ocfs2_extend_trans(handle, credits);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move half of the xattr in start_blk to the next bucket. */
|
2008-10-26 16:06:24 -06:00
|
|
|
return ocfs2_divide_xattr_bucket(inode, handle, prev_blk,
|
|
|
|
new_blk, first_hash, 1);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move some xattrs from the old cluster to the new one since they are not
|
|
|
|
* contiguous in ocfs2 xattr tree.
|
|
|
|
*
|
|
|
|
* new_blk starts a new separate cluster, and we will move some xattrs from
|
|
|
|
* prev_blk to it. v_start will be set as the first name hash value in this
|
|
|
|
* new cluster so that it can be used as e_cpos during tree insertion and
|
|
|
|
* don't collide with our original b-tree operations. first_bh and header_bh
|
|
|
|
* will also be updated since they will be used in ocfs2_extend_xattr_bucket
|
|
|
|
* to extend the insert bucket.
|
|
|
|
*
|
|
|
|
* The problem is how much xattr should we move to the new one and when should
|
|
|
|
* we update first_bh and header_bh?
|
|
|
|
* 1. If cluster size > bucket size, that means the previous cluster has more
|
|
|
|
* than 1 bucket, so just move half nums of bucket into the new cluster and
|
|
|
|
* update the first_bh and header_bh if the insert bucket has been moved
|
|
|
|
* to the new cluster.
|
|
|
|
* 2. If cluster_size == bucket_size:
|
|
|
|
* a) If the previous extent rec has more than one cluster and the insert
|
|
|
|
* place isn't in the last cluster, copy the entire last cluster to the
|
|
|
|
* new one. This time, we don't need to upate the first_bh and header_bh
|
|
|
|
* since they will not be moved into the new cluster.
|
|
|
|
* b) Otherwise, move the bottom half of the xattrs in the last cluster into
|
|
|
|
* the new one. And we set the extend flag to zero if the insert place is
|
|
|
|
* moved into the new allocated cluster since no extend is needed.
|
|
|
|
*/
|
|
|
|
static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
|
|
|
|
handle_t *handle,
|
2008-11-26 15:43:31 -07:00
|
|
|
struct ocfs2_xattr_bucket *first,
|
|
|
|
struct ocfs2_xattr_bucket *target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u64 new_blk,
|
|
|
|
u32 prev_clusters,
|
|
|
|
u32 *v_start,
|
|
|
|
int *extend)
|
|
|
|
{
|
2008-11-26 15:12:09 -07:00
|
|
|
int ret;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
|
2008-11-26 15:43:31 -07:00
|
|
|
(unsigned long long)bucket_blkno(first), prev_clusters,
|
2008-10-29 15:45:30 -06:00
|
|
|
(unsigned long long)new_blk);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 15:25:21 -07:00
|
|
|
if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_mv_xattr_bucket_cross_cluster(inode,
|
|
|
|
handle,
|
2008-11-26 15:25:21 -07:00
|
|
|
first, target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
new_blk,
|
|
|
|
prev_clusters,
|
|
|
|
v_start);
|
2008-11-26 15:43:31 -07:00
|
|
|
if (ret)
|
2008-11-26 15:25:21 -07:00
|
|
|
mlog_errno(ret);
|
|
|
|
} else {
|
2008-11-26 15:12:09 -07:00
|
|
|
/* The start of the last cluster in the first extent */
|
|
|
|
u64 last_blk = bucket_blkno(first) +
|
|
|
|
((prev_clusters - 1) *
|
|
|
|
ocfs2_clusters_to_blocks(inode->i_sb, 1));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 15:43:31 -07:00
|
|
|
if (prev_clusters > 1 && bucket_blkno(target) != last_blk) {
|
2008-11-26 14:02:18 -07:00
|
|
|
ret = ocfs2_mv_xattr_buckets(inode, handle,
|
2008-11-26 15:12:09 -07:00
|
|
|
bucket_blkno(first),
|
2008-11-26 14:18:31 -07:00
|
|
|
last_blk, new_blk, 0,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
v_start);
|
2008-11-26 15:43:31 -07:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
} else {
|
2008-10-26 16:06:24 -06:00
|
|
|
ret = ocfs2_divide_xattr_cluster(inode, handle,
|
|
|
|
last_blk, new_blk,
|
|
|
|
v_start);
|
2008-11-26 15:43:31 -07:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 15:12:09 -07:00
|
|
|
if ((bucket_blkno(target) == last_blk) && extend)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*extend = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a new cluster for xattr storage.
|
|
|
|
*
|
|
|
|
* If the new cluster is contiguous with the previous one, it will be
|
|
|
|
* appended to the same extent record, and num_clusters will be updated.
|
|
|
|
* If not, we will insert a new extent for it and move some xattrs in
|
|
|
|
* the last cluster into the new allocated one.
|
|
|
|
* We also need to limit the maximum size of a btree leaf, otherwise we'll
|
|
|
|
* lose the benefits of hashing because we'll have to search large leaves.
|
|
|
|
* So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
|
|
|
|
* if it's bigger).
|
|
|
|
*
|
|
|
|
* first_bh is the first block of the previous extent rec and header_bh
|
|
|
|
* indicates the bucket we will insert the new xattrs. They will be updated
|
|
|
|
* when the header_bh is moved into the new cluster.
|
|
|
|
*/
|
|
|
|
static int ocfs2_add_new_xattr_cluster(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
2008-11-26 16:08:44 -07:00
|
|
|
struct ocfs2_xattr_bucket *first,
|
|
|
|
struct ocfs2_xattr_bucket *target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u32 *num_clusters,
|
|
|
|
u32 prev_cpos,
|
2008-11-11 17:27:00 -07:00
|
|
|
int *extend,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
2008-11-11 17:27:01 -07:00
|
|
|
int ret;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
|
|
|
|
u32 prev_clusters = *num_clusters;
|
|
|
|
u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0;
|
|
|
|
u64 block;
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle = ctxt->handle;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
2008-08-20 20:36:33 -06:00
|
|
|
struct ocfs2_extent_tree et;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
|
|
|
|
"previous xattr blkno = %llu\n",
|
|
|
|
(unsigned long long)OCFS2_I(inode)->ip_blkno,
|
2008-11-26 16:08:44 -07:00
|
|
|
prev_cpos, (unsigned long long)bucket_blkno(first));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2009-02-13 04:54:22 -07:00
|
|
|
ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
|
2008-08-20 20:36:33 -06:00
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
|
2008-12-09 17:11:49 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = __ocfs2_claim_clusters(osb, handle, ctxt->data_ac, 1,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
clusters_to_add, &bit_off, &num_bits);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (ret != -ENOSPC)
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(num_bits > clusters_to_add);
|
|
|
|
|
|
|
|
block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
|
|
|
|
mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
|
|
|
|
num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
|
|
|
|
|
2008-11-26 16:08:44 -07:00
|
|
|
if (bucket_blkno(first) + (prev_clusters * bpc) == block &&
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
(prev_clusters + num_bits) << osb->s_clustersize_bits <=
|
|
|
|
OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
|
|
|
|
/*
|
|
|
|
* If this cluster is contiguous with the old one and
|
|
|
|
* adding this new cluster, we don't surpass the limit of
|
|
|
|
* OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
|
|
|
|
* initialized and used like other buckets in the previous
|
|
|
|
* cluster.
|
|
|
|
* So add it as a contiguous one. The caller will handle
|
|
|
|
* its init process.
|
|
|
|
*/
|
|
|
|
v_start = prev_cpos + prev_clusters;
|
|
|
|
*num_clusters = prev_clusters + num_bits;
|
|
|
|
mlog(0, "Add contiguous %u clusters to previous extent rec.\n",
|
|
|
|
num_bits);
|
|
|
|
} else {
|
|
|
|
ret = ocfs2_adjust_xattr_cross_cluster(inode,
|
|
|
|
handle,
|
2008-11-26 15:43:31 -07:00
|
|
|
first,
|
|
|
|
target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
block,
|
|
|
|
prev_clusters,
|
|
|
|
&v_start,
|
|
|
|
extend);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
|
2008-10-29 15:45:30 -06:00
|
|
|
num_bits, (unsigned long long)block, v_start);
|
2009-02-13 04:24:43 -07:00
|
|
|
ret = ocfs2_insert_extent(handle, &et, v_start, block,
|
2008-11-11 17:27:00 -07:00
|
|
|
num_bits, 0, ctxt->meta_ac);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_journal_dirty(handle, root_bh);
|
2008-11-11 17:27:01 -07:00
|
|
|
if (ret < 0)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
leave:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-25 18:06:40 -07:00
|
|
|
* We are given an extent. 'first' is the bucket at the very front of
|
|
|
|
* the extent. The extent has space for an additional bucket past
|
|
|
|
* bucket_xh(first)->xh_num_buckets. 'target_blkno' is the block number
|
|
|
|
* of the target bucket. We wish to shift every bucket past the target
|
|
|
|
* down one, filling in that additional space. When we get back to the
|
|
|
|
* target, we split the target between itself and the now-empty bucket
|
|
|
|
* at target+1 (aka, target_blkno + blks_per_bucket).
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
|
|
|
static int ocfs2_extend_xattr_bucket(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
2008-11-25 18:06:40 -07:00
|
|
|
struct ocfs2_xattr_bucket *first,
|
|
|
|
u64 target_blk,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
u32 num_clusters)
|
|
|
|
{
|
|
|
|
int ret, credits;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2008-11-25 18:06:40 -07:00
|
|
|
u64 end_blk;
|
|
|
|
u16 new_bucket = le16_to_cpu(bucket_xh(first)->xh_num_buckets);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
|
2008-11-25 18:06:40 -07:00
|
|
|
"from %llu, len = %u\n", (unsigned long long)target_blk,
|
|
|
|
(unsigned long long)bucket_blkno(first), num_clusters);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
/* The extent must have room for an additional bucket */
|
|
|
|
BUG_ON(new_bucket >=
|
|
|
|
(num_clusters * ocfs2_xattr_buckets_per_cluster(osb)));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
/* end_blk points to the last existing bucket */
|
|
|
|
end_blk = bucket_blkno(first) + ((new_bucket - 1) * blk_per_bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
/*
|
2008-11-25 18:06:40 -07:00
|
|
|
* end_blk is the start of the last existing bucket.
|
|
|
|
* Thus, (end_blk - target_blk) covers the target bucket and
|
|
|
|
* every bucket after it up to, but not including, the last
|
|
|
|
* existing bucket. Then we add the last existing bucket, the
|
|
|
|
* new bucket, and the first bucket (3 * blk_per_bucket).
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
2008-11-25 18:06:40 -07:00
|
|
|
credits = (end_blk - target_blk) + (3 * blk_per_bucket) +
|
2008-11-11 17:27:01 -07:00
|
|
|
handle->h_buffer_credits;
|
|
|
|
ret = ocfs2_extend_trans(handle, credits);
|
|
|
|
if (ret) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, first,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
while (end_blk != target_blk) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk,
|
|
|
|
end_blk + blk_per_bucket, 0);
|
|
|
|
if (ret)
|
2008-11-11 17:27:01 -07:00
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
end_blk -= blk_per_bucket;
|
|
|
|
}
|
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
/* Move half of the xattr in target_blkno to the next bucket. */
|
|
|
|
ret = ocfs2_divide_xattr_bucket(inode, handle, target_blk,
|
|
|
|
target_blk + blk_per_bucket, NULL, 0);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
le16_add_cpu(&bucket_xh(first)->xh_num_buckets, 1);
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, first);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-26 16:25:41 -07:00
|
|
|
* Add new xattr bucket in an extent record and adjust the buckets
|
|
|
|
* accordingly. xb_bh is the ocfs2_xattr_block, and target is the
|
|
|
|
* bucket we want to insert into.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*
|
2008-11-26 16:25:41 -07:00
|
|
|
* In the easy case, we will move all the buckets after target down by
|
|
|
|
* one. Half of target's xattrs will be moved to the next bucket.
|
|
|
|
*
|
|
|
|
* If current cluster is full, we'll allocate a new one. This may not
|
|
|
|
* be contiguous. The underlying calls will make sure that there is
|
|
|
|
* space for the insert, shifting buckets around if necessary.
|
|
|
|
* 'target' may be moved by those calls.
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
*/
|
|
|
|
static int ocfs2_add_new_xattr_bucket(struct inode *inode,
|
|
|
|
struct buffer_head *xb_bh,
|
2008-11-26 16:25:41 -07:00
|
|
|
struct ocfs2_xattr_bucket *target,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)xb_bh->b_data;
|
|
|
|
struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
|
|
|
|
struct ocfs2_extent_list *el = &xb_root->xt_list;
|
2008-11-26 16:25:41 -07:00
|
|
|
u32 name_hash =
|
|
|
|
le32_to_cpu(bucket_xh(target)->xh_entries[0].xe_name_hash);
|
2008-11-26 16:08:44 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
int ret, num_buckets, extend = 1;
|
|
|
|
u64 p_blkno;
|
|
|
|
u32 e_cpos, num_clusters;
|
2008-11-25 18:06:40 -07:00
|
|
|
/* The bucket at the front of the extent */
|
2008-11-26 16:25:41 -07:00
|
|
|
struct ocfs2_xattr_bucket *first;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 16:25:41 -07:00
|
|
|
mlog(0, "Add new xattr bucket starting from %llu\n",
|
|
|
|
(unsigned long long)bucket_blkno(target));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-26 16:08:44 -07:00
|
|
|
/* The first bucket of the original extent */
|
2008-11-25 18:06:40 -07:00
|
|
|
first = ocfs2_xattr_bucket_new(inode);
|
2008-11-26 16:25:41 -07:00
|
|
|
if (!first) {
|
2008-11-25 18:06:40 -07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos,
|
|
|
|
&num_clusters, el);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-26 16:08:44 -07:00
|
|
|
ret = ocfs2_read_xattr_bucket(first, p_blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-26 16:08:44 -07:00
|
|
|
num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters;
|
|
|
|
if (num_buckets == le16_to_cpu(bucket_xh(first)->xh_num_buckets)) {
|
|
|
|
/*
|
|
|
|
* This can move first+target if the target bucket moves
|
|
|
|
* to the new extent.
|
|
|
|
*/
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_add_new_xattr_cluster(inode,
|
|
|
|
xb_bh,
|
2008-11-26 16:08:44 -07:00
|
|
|
first,
|
|
|
|
target,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
&num_clusters,
|
|
|
|
e_cpos,
|
2008-11-11 17:27:00 -07:00
|
|
|
&extend,
|
|
|
|
ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-25 18:06:40 -07:00
|
|
|
if (extend) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_extend_xattr_bucket(inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
ctxt->handle,
|
2008-11-26 16:08:44 -07:00
|
|
|
first,
|
|
|
|
bucket_blkno(target),
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
num_clusters);
|
2008-11-25 18:06:40 -07:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
}
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
out:
|
2008-11-25 18:06:40 -07:00
|
|
|
ocfs2_xattr_bucket_free(first);
|
2008-11-26 16:08:44 -07:00
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline char *ocfs2_xattr_bucket_get_val(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
int offs)
|
|
|
|
{
|
|
|
|
int block_off = offs >> inode->i_sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
offs = offs % inode->i_sb->s_blocksize;
|
2008-10-24 17:57:21 -06:00
|
|
|
return bucket_block(bucket, block_off) + offs;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle the normal xattr set, including replace, delete and new.
|
|
|
|
*
|
|
|
|
* Note: "local" indicates the real data's locality. So we can't
|
|
|
|
* just its bucket locality by its length.
|
|
|
|
*/
|
|
|
|
static void ocfs2_xattr_set_entry_normal(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
u32 name_hash,
|
2008-09-19 08:17:41 -06:00
|
|
|
int local)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *last, *xe;
|
|
|
|
int name_len = strlen(xi->name);
|
|
|
|
struct ocfs2_xattr_header *xh = xs->header;
|
|
|
|
u16 count = le16_to_cpu(xh->xh_count), start;
|
|
|
|
size_t blocksize = inode->i_sb->s_blocksize;
|
|
|
|
char *val;
|
|
|
|
size_t offs, size, new_size;
|
|
|
|
|
|
|
|
last = &xh->xh_entries[count];
|
|
|
|
if (!xs->not_found) {
|
|
|
|
xe = xs->here;
|
|
|
|
offs = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
|
|
|
|
else
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the new value will be stored outside, xi->value has been
|
|
|
|
* initalized as an empty ocfs2_xattr_value_root, and the same
|
|
|
|
* goes with xi->value_len, so we can set new_size safely here.
|
|
|
|
* See ocfs2_xattr_set_in_bucket.
|
|
|
|
*/
|
|
|
|
new_size = OCFS2_XATTR_SIZE(name_len) +
|
|
|
|
OCFS2_XATTR_SIZE(xi->value_len);
|
|
|
|
|
|
|
|
le16_add_cpu(&xh->xh_name_value_len, -size);
|
|
|
|
if (xi->value) {
|
|
|
|
if (new_size > size)
|
|
|
|
goto set_new_name_value;
|
|
|
|
|
|
|
|
/* Now replace the old value with new one. */
|
|
|
|
if (local)
|
|
|
|
xe->xe_value_size = cpu_to_le64(xi->value_len);
|
|
|
|
else
|
|
|
|
xe->xe_value_size = 0;
|
|
|
|
|
|
|
|
val = ocfs2_xattr_bucket_get_val(inode,
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->bucket, offs);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
memset(val + OCFS2_XATTR_SIZE(name_len), 0,
|
|
|
|
size - OCFS2_XATTR_SIZE(name_len));
|
|
|
|
if (OCFS2_XATTR_SIZE(xi->value_len) > 0)
|
|
|
|
memcpy(val + OCFS2_XATTR_SIZE(name_len),
|
|
|
|
xi->value, xi->value_len);
|
|
|
|
|
|
|
|
le16_add_cpu(&xh->xh_name_value_len, new_size);
|
|
|
|
ocfs2_xattr_set_local(xe, local);
|
|
|
|
return;
|
|
|
|
} else {
|
2008-09-19 08:17:41 -06:00
|
|
|
/*
|
|
|
|
* Remove the old entry if there is more than one.
|
|
|
|
* We don't remove the last entry so that we can
|
|
|
|
* use it to indicate the hash value of the empty
|
|
|
|
* bucket.
|
|
|
|
*/
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
last -= 1;
|
|
|
|
le16_add_cpu(&xh->xh_count, -1);
|
2008-09-19 08:17:41 -06:00
|
|
|
if (xh->xh_count) {
|
|
|
|
memmove(xe, xe + 1,
|
|
|
|
(void *)last - (void *)xe);
|
|
|
|
memset(last, 0,
|
|
|
|
sizeof(struct ocfs2_xattr_entry));
|
|
|
|
} else
|
|
|
|
xh->xh_free_start =
|
|
|
|
cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* find a new entry for insert. */
|
|
|
|
int low = 0, high = count - 1, tmp;
|
|
|
|
struct ocfs2_xattr_entry *tmp_xe;
|
|
|
|
|
2008-09-19 08:17:41 -06:00
|
|
|
while (low <= high && count) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
tmp = (low + high) / 2;
|
|
|
|
tmp_xe = &xh->xh_entries[tmp];
|
|
|
|
|
|
|
|
if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash))
|
|
|
|
low = tmp + 1;
|
|
|
|
else if (name_hash <
|
|
|
|
le32_to_cpu(tmp_xe->xe_name_hash))
|
|
|
|
high = tmp - 1;
|
2008-09-19 08:16:34 -06:00
|
|
|
else {
|
|
|
|
low = tmp;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
break;
|
2008-09-19 08:16:34 -06:00
|
|
|
}
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xe = &xh->xh_entries[low];
|
|
|
|
if (low != count)
|
|
|
|
memmove(xe + 1, xe, (void *)last - (void *)xe);
|
|
|
|
|
|
|
|
le16_add_cpu(&xh->xh_count, 1);
|
|
|
|
memset(xe, 0, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
xe->xe_name_hash = cpu_to_le32(name_hash);
|
|
|
|
xe->xe_name_len = name_len;
|
|
|
|
ocfs2_xattr_set_type(xe, xi->name_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
set_new_name_value:
|
|
|
|
/* Insert the new name+value. */
|
|
|
|
size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(xi->value_len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We must make sure that the name/value pair
|
|
|
|
* exists in the same block.
|
|
|
|
*/
|
|
|
|
offs = le16_to_cpu(xh->xh_free_start);
|
|
|
|
start = offs - size;
|
|
|
|
|
|
|
|
if (start >> inode->i_sb->s_blocksize_bits !=
|
|
|
|
(offs - 1) >> inode->i_sb->s_blocksize_bits) {
|
|
|
|
offs = offs - offs % blocksize;
|
|
|
|
xh->xh_free_start = cpu_to_le16(offs);
|
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
val = ocfs2_xattr_bucket_get_val(inode, xs->bucket, offs - size);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
xe->xe_name_offset = cpu_to_le16(offs - size);
|
|
|
|
|
|
|
|
memset(val, 0, size);
|
|
|
|
memcpy(val, xi->name, name_len);
|
|
|
|
memcpy(val + OCFS2_XATTR_SIZE(name_len), xi->value, xi->value_len);
|
|
|
|
|
|
|
|
xe->xe_value_size = cpu_to_le64(xi->value_len);
|
|
|
|
ocfs2_xattr_set_local(xe, local);
|
|
|
|
xs->here = xe;
|
|
|
|
le16_add_cpu(&xh->xh_free_start, -size);
|
|
|
|
le16_add_cpu(&xh->xh_name_value_len, size);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the xattr entry in the specified bucket.
|
|
|
|
* The bucket is indicated by xs->bucket and it should have the enough
|
|
|
|
* space for the xattr insertion.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_info *xi,
|
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
u32 name_hash,
|
2008-09-19 08:17:41 -06:00
|
|
|
int local)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
2008-10-24 19:47:33 -06:00
|
|
|
int ret;
|
2008-10-27 19:07:45 -06:00
|
|
|
u64 blkno;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-08-19 11:54:29 -06:00
|
|
|
mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
|
|
|
|
(unsigned long)xi->value_len, xi->name_index,
|
2008-10-24 20:13:20 -06:00
|
|
|
(unsigned long long)bucket_blkno(xs->bucket));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
if (!xs->bucket->bu_bhs[1]) {
|
2008-10-27 19:07:45 -06:00
|
|
|
blkno = bucket_blkno(xs->bucket);
|
|
|
|
ocfs2_xattr_bucket_relse(xs->bucket);
|
|
|
|
ret = ocfs2_read_xattr_bucket(xs->bucket, blkno);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
|
2008-10-24 19:47:33 -06:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-09-19 08:17:41 -06:00
|
|
|
ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local);
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Truncate the specified xe_off entry in xattr bucket.
|
|
|
|
* bucket is indicated by header_bh and len is the new length.
|
|
|
|
* Both the ocfs2_xattr_value_root and the entry will be updated here.
|
|
|
|
*
|
|
|
|
* Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
|
2008-11-24 20:32:13 -07:00
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
int xe_off,
|
2008-11-11 17:27:00 -07:00
|
|
|
int len,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int ret, offset;
|
|
|
|
u64 value_blk;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
2008-11-24 20:32:13 -07:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
size_t blocksize = inode->i_sb->s_blocksize;
|
2008-12-09 16:01:04 -07:00
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_access = ocfs2_journal_access,
|
|
|
|
};
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
xe = &xh->xh_entries[xe_off];
|
|
|
|
|
|
|
|
BUG_ON(!xe || ocfs2_xattr_is_local(xe));
|
|
|
|
|
|
|
|
offset = le16_to_cpu(xe->xe_name_offset) +
|
|
|
|
OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
|
|
|
|
value_blk = offset / blocksize;
|
|
|
|
|
|
|
|
/* We don't allow ocfs2_xattr_value to be stored in different block. */
|
|
|
|
BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize);
|
|
|
|
|
2008-12-09 16:01:04 -07:00
|
|
|
vb.vb_bh = bucket->bu_bhs[value_blk];
|
|
|
|
BUG_ON(!vb.vb_bh);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-12-09 16:01:04 -07:00
|
|
|
vb.vb_xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(vb.vb_bh->b_data + offset % blocksize);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-11-24 20:32:13 -07:00
|
|
|
/*
|
|
|
|
* From here on out we have to dirty the bucket. The generic
|
|
|
|
* value calls only modify one of the bucket's bhs, but we need
|
|
|
|
* to send the bucket at once. So if they error, they *could* have
|
|
|
|
* modified something. We have to assume they did, and dirty
|
|
|
|
* the whole bucket. This leaves us in a consistent state.
|
|
|
|
*/
|
|
|
|
mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
|
|
|
|
xe_off, (unsigned long long)bucket_blkno(bucket), len);
|
2008-12-09 16:01:04 -07:00
|
|
|
ret = ocfs2_xattr_value_truncate(inode, &vb, len, ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2009-01-07 17:21:43 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
2008-11-24 20:32:13 -07:00
|
|
|
xe->xe_value_size = cpu_to_le64(len);
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);
|
|
|
|
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
int len,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int ret, offset;
|
|
|
|
struct ocfs2_xattr_entry *xe = xs->here;
|
|
|
|
struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
BUG_ON(!xs->bucket->bu_bhs[0] || !xe || ocfs2_xattr_is_local(xe));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
offset = xe - xh->xh_entries;
|
2008-11-24 20:32:13 -07:00
|
|
|
ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket,
|
2008-11-11 17:27:00 -07:00
|
|
|
offset, len, ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
char *val,
|
|
|
|
int value_len)
|
|
|
|
{
|
2009-03-11 18:37:34 -06:00
|
|
|
int ret, offset, block_off;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv;
|
|
|
|
struct ocfs2_xattr_entry *xe = xs->here;
|
2009-03-11 18:37:34 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket);
|
|
|
|
void *base;
|
2009-08-17 21:43:17 -06:00
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_access = ocfs2_journal_access,
|
|
|
|
};
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
BUG_ON(!xs->base || !xe || ocfs2_xattr_is_local(xe));
|
|
|
|
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, xh,
|
2009-03-11 18:37:34 -06:00
|
|
|
xe - xh->xh_entries,
|
|
|
|
&block_off,
|
|
|
|
&offset);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2009-03-11 18:37:34 -06:00
|
|
|
base = bucket_block(xs->bucket, block_off);
|
|
|
|
xv = (struct ocfs2_xattr_value_root *)(base + offset +
|
|
|
|
OCFS2_XATTR_SIZE(xe->xe_name_len));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
vb.vb_xv = xv;
|
|
|
|
vb.vb_bh = xs->bucket->bu_bhs[block_off];
|
2009-03-11 18:37:34 -06:00
|
|
|
ret = __ocfs2_xattr_set_value_outside(inode, handle,
|
2009-08-17 21:43:17 -06:00
|
|
|
&vb, val, value_len);
|
2009-03-11 18:37:34 -06:00
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
out:
|
|
|
|
return ret;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_rm_xattr_cluster(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno,
|
|
|
|
u32 cpos,
|
2009-08-17 21:43:42 -06:00
|
|
|
u32 len,
|
|
|
|
void *para)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct inode *tl_inode = osb->osb_tl_inode;
|
|
|
|
handle_t *handle;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)root_bh->b_data;
|
|
|
|
struct ocfs2_alloc_context *meta_ac = NULL;
|
|
|
|
struct ocfs2_cached_dealloc_ctxt dealloc;
|
2008-08-20 20:36:33 -06:00
|
|
|
struct ocfs2_extent_tree et;
|
|
|
|
|
2009-08-17 21:43:42 -06:00
|
|
|
ret = ocfs2_iterate_xattr_buckets(inode, blkno, len,
|
2009-08-17 21:43:59 -06:00
|
|
|
ocfs2_delete_xattr_in_bucket, para);
|
2009-08-17 21:43:42 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-02-13 04:54:22 -07:00
|
|
|
ocfs2_init_xattr_tree_extent_tree(&et, INODE_CACHE(inode), root_bh);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
ocfs2_init_dealloc_ctxt(&dealloc);
|
|
|
|
|
|
|
|
mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
|
|
|
|
cpos, len, (unsigned long long)blkno);
|
|
|
|
|
2009-02-10 21:00:41 -07:00
|
|
|
ocfs2_remove_xattr_clusters_from_cache(INODE_CACHE(inode), blkno,
|
|
|
|
len);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-08-20 20:36:33 -06:00
|
|
|
ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&tl_inode->i_mutex);
|
|
|
|
|
|
|
|
if (ocfs2_truncate_log_needs_flush(osb)) {
|
|
|
|
ret = __ocfs2_flush_truncate_log(osb);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-09 11:38:40 -06:00
|
|
|
handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb));
|
2008-10-23 17:57:28 -06:00
|
|
|
if (IS_ERR(handle)) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-02-12 17:41:25 -07:00
|
|
|
ret = ocfs2_journal_access_xb(handle, INODE_CACHE(inode), root_bh,
|
2008-12-09 17:11:49 -07:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
2009-02-13 04:41:26 -07:00
|
|
|
ret = ocfs2_remove_extent(handle, &et, cpos, len, meta_ac,
|
2008-08-20 20:36:33 -06:00
|
|
|
&dealloc);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len);
|
|
|
|
|
|
|
|
ret = ocfs2_journal_dirty(handle, root_bh);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_truncate_log_append(osb, handle, blkno, len);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out_commit:
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
out:
|
|
|
|
ocfs2_schedule_truncate_log_flush(osb, 1);
|
|
|
|
|
|
|
|
mutex_unlock(&tl_inode->i_mutex);
|
|
|
|
|
|
|
|
if (meta_ac)
|
|
|
|
ocfs2_free_alloc_context(meta_ac);
|
|
|
|
|
|
|
|
ocfs2_run_deallocs(osb, &dealloc);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
|
2008-11-11 17:27:01 -07:00
|
|
|
handle_t *handle,
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_search *xs)
|
|
|
|
{
|
2008-10-24 20:13:20 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
struct ocfs2_xattr_entry *last = &xh->xh_entries[
|
|
|
|
le16_to_cpu(xh->xh_count) - 1];
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,
|
2008-10-24 19:47:33 -06:00
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
2008-11-11 17:27:01 -07:00
|
|
|
return;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove the old entry. */
|
|
|
|
memmove(xs->here, xs->here + 1,
|
|
|
|
(void *)last - (void *)xs->here);
|
|
|
|
memset(last, 0, sizeof(struct ocfs2_xattr_entry));
|
|
|
|
le16_add_cpu(&xh->xh_count, -1);
|
|
|
|
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the xattr name/value in the bucket specified in xs.
|
|
|
|
*
|
|
|
|
* As the new value in xi may be stored in the bucket or in an outside cluster,
|
|
|
|
* we divide the whole process into 3 steps:
|
|
|
|
* 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
|
|
|
|
* 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
|
|
|
|
* 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
|
|
|
|
* 4. If the clusters for the new outside value can't be allocated, we need
|
|
|
|
* to free the xattr we allocated in set.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_set_in_bucket(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
2008-09-19 08:17:41 -06:00
|
|
|
int ret, local = 1;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
size_t value_len;
|
|
|
|
char *val = (char *)xi->value;
|
|
|
|
struct ocfs2_xattr_entry *xe = xs->here;
|
2008-10-09 09:06:13 -06:00
|
|
|
u32 name_hash = ocfs2_xattr_name_hash(inode, xi->name,
|
|
|
|
strlen(xi->name));
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
if (!xs->not_found && !ocfs2_xattr_is_local(xe)) {
|
|
|
|
/*
|
|
|
|
* We need to truncate the xattr storage first.
|
|
|
|
*
|
|
|
|
* If both the old and new value are stored to
|
|
|
|
* outside block, we only need to truncate
|
|
|
|
* the storage and then set the value outside.
|
|
|
|
*
|
|
|
|
* If the new value should be stored within block,
|
|
|
|
* we should free all the outside block first and
|
|
|
|
* the modification to the xattr block will be done
|
|
|
|
* by following steps.
|
|
|
|
*/
|
|
|
|
if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
value_len = xi->value_len;
|
|
|
|
else
|
|
|
|
value_len = 0;
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
|
2008-11-11 17:27:00 -07:00
|
|
|
value_len,
|
|
|
|
ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (value_len)
|
|
|
|
goto set_value_outside;
|
|
|
|
}
|
|
|
|
|
|
|
|
value_len = xi->value_len;
|
|
|
|
/* So we have to handle the inside block change now. */
|
|
|
|
if (value_len > OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
/*
|
|
|
|
* If the new value will be stored outside of block,
|
|
|
|
* initalize a new empty value root and insert it first.
|
|
|
|
*/
|
|
|
|
local = 0;
|
|
|
|
xi->value = &def_xv;
|
|
|
|
xi->value_len = OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
}
|
|
|
|
|
2008-11-11 17:27:01 -07:00
|
|
|
ret = ocfs2_xattr_set_entry_in_bucket(inode, ctxt->handle, xi, xs,
|
|
|
|
name_hash, local);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-09-19 08:17:41 -06:00
|
|
|
if (value_len <= OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
goto out;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
2008-09-19 08:17:41 -06:00
|
|
|
/* allocate the space now for the outside block storage. */
|
|
|
|
ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
|
2008-11-11 17:27:00 -07:00
|
|
|
value_len, ctxt);
|
2008-09-19 08:17:41 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
if (xs->not_found) {
|
|
|
|
/*
|
|
|
|
* We can't allocate enough clusters for outside
|
|
|
|
* storage and we have allocated xattr already,
|
|
|
|
* so need to remove it.
|
|
|
|
*/
|
2008-11-11 17:27:01 -07:00
|
|
|
ocfs2_xattr_bucket_remove_xs(inode, ctxt->handle, xs);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_value_outside:
|
2008-11-11 17:27:01 -07:00
|
|
|
ret = ocfs2_xattr_bucket_set_value_outside(inode, ctxt->handle,
|
|
|
|
xs, val, value_len);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-10-26 16:06:24 -06:00
|
|
|
/*
|
|
|
|
* check whether the xattr bucket is filled up with the same hash value.
|
|
|
|
* If we want to insert the xattr with the same hash, return -ENOSPC.
|
|
|
|
* If we want to insert a xattr with different hash value, go ahead
|
|
|
|
* and ocfs2_divide_xattr_bucket will handle this.
|
|
|
|
*/
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
static int ocfs2_check_xattr_bucket_collision(struct inode *inode,
|
2008-10-26 16:06:24 -06:00
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
const char *name)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
2008-10-24 18:04:49 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
2008-10-26 16:06:24 -06:00
|
|
|
u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
|
|
|
|
|
|
|
|
if (name_hash != le32_to_cpu(xh->xh_entries[0].xe_name_hash))
|
|
|
|
return 0;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash ==
|
|
|
|
xh->xh_entries[0].xe_name_hash) {
|
|
|
|
mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, "
|
|
|
|
"hash = %u\n",
|
2008-10-24 17:21:03 -06:00
|
|
|
(unsigned long long)bucket_blkno(bucket),
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
le32_to_cpu(xh->xh_entries[0].xe_name_hash));
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_info *xi,
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_xattr_search *xs,
|
|
|
|
struct ocfs2_xattr_set_ctxt *ctxt)
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
{
|
|
|
|
struct ocfs2_xattr_header *xh;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
u16 count, header_size, xh_free_start;
|
2008-10-24 18:16:48 -06:00
|
|
|
int free, max_free, need, old;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
size_t value_size = 0, name_len = strlen(xi->name);
|
|
|
|
size_t blocksize = inode->i_sb->s_blocksize;
|
|
|
|
int ret, allocation = 0;
|
|
|
|
|
|
|
|
mlog_entry("Set xattr %s in xattr index block\n", xi->name);
|
|
|
|
|
|
|
|
try_again:
|
|
|
|
xh = xs->header;
|
|
|
|
count = le16_to_cpu(xh->xh_count);
|
|
|
|
xh_free_start = le16_to_cpu(xh->xh_free_start);
|
|
|
|
header_size = sizeof(struct ocfs2_xattr_header) +
|
|
|
|
count * sizeof(struct ocfs2_xattr_entry);
|
2009-02-19 20:11:50 -07:00
|
|
|
max_free = OCFS2_XATTR_BUCKET_SIZE - header_size -
|
|
|
|
le16_to_cpu(xh->xh_name_value_len) - OCFS2_XATTR_HEADER_GAP;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
|
|
|
|
mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size "
|
|
|
|
"of %u which exceed block size\n",
|
2008-10-24 20:13:20 -06:00
|
|
|
(unsigned long long)bucket_blkno(xs->bucket),
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
header_size);
|
|
|
|
|
|
|
|
if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE)
|
|
|
|
value_size = OCFS2_XATTR_ROOT_SIZE;
|
|
|
|
else if (xi->value)
|
|
|
|
value_size = OCFS2_XATTR_SIZE(xi->value_len);
|
|
|
|
|
|
|
|
if (xs->not_found)
|
|
|
|
need = sizeof(struct ocfs2_xattr_entry) +
|
|
|
|
OCFS2_XATTR_SIZE(name_len) + value_size;
|
|
|
|
else {
|
|
|
|
need = value_size + OCFS2_XATTR_SIZE(name_len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only replace the old value if the new length is smaller
|
|
|
|
* than the old one. Otherwise we will allocate new space in the
|
|
|
|
* bucket to store it.
|
|
|
|
*/
|
|
|
|
xe = xs->here;
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
old = OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
|
|
|
|
else
|
|
|
|
old = OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE);
|
|
|
|
|
|
|
|
if (old >= value_size)
|
|
|
|
need = 0;
|
|
|
|
}
|
|
|
|
|
2009-02-19 20:11:50 -07:00
|
|
|
free = xh_free_start - header_size - OCFS2_XATTR_HEADER_GAP;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
/*
|
|
|
|
* We need to make sure the new name/value pair
|
|
|
|
* can exist in the same block.
|
|
|
|
*/
|
|
|
|
if (xh_free_start % blocksize < need)
|
|
|
|
free -= xh_free_start % blocksize;
|
|
|
|
|
|
|
|
mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
|
|
|
|
"need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
|
|
|
|
" %u\n", xs->not_found,
|
2008-10-24 20:13:20 -06:00
|
|
|
(unsigned long long)bucket_blkno(xs->bucket),
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
free, need, max_free, le16_to_cpu(xh->xh_free_start),
|
|
|
|
le16_to_cpu(xh->xh_name_value_len));
|
|
|
|
|
2008-11-11 17:26:57 -07:00
|
|
|
if (free < need ||
|
|
|
|
(xs->not_found &&
|
|
|
|
count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb))) {
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (need <= max_free &&
|
|
|
|
count < ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) {
|
|
|
|
/*
|
|
|
|
* We can create the space by defragment. Since only the
|
|
|
|
* name/value will be moved, the xe shouldn't be changed
|
|
|
|
* in xs.
|
|
|
|
*/
|
2008-11-11 17:27:01 -07:00
|
|
|
ret = ocfs2_defrag_xattr_bucket(inode, ctxt->handle,
|
|
|
|
xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
xh_free_start = le16_to_cpu(xh->xh_free_start);
|
2009-02-19 20:11:50 -07:00
|
|
|
free = xh_free_start - header_size
|
|
|
|
- OCFS2_XATTR_HEADER_GAP;
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (xh_free_start % blocksize < need)
|
|
|
|
free -= xh_free_start % blocksize;
|
|
|
|
|
|
|
|
if (free >= need)
|
|
|
|
goto xattr_set;
|
|
|
|
|
|
|
|
mlog(0, "Can't get enough space for xattr insert by "
|
|
|
|
"defragment. Need %u bytes, but we have %d, so "
|
|
|
|
"allocate new bucket for it.\n", need, free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to add new buckets or clusters and one
|
|
|
|
* allocation should leave us enough space for insert.
|
|
|
|
*/
|
|
|
|
BUG_ON(allocation);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We do not allow for overlapping ranges between buckets. And
|
|
|
|
* the maximum number of collisions we will allow for then is
|
|
|
|
* one bucket's worth, so check it here whether we need to
|
|
|
|
* add a new bucket for the insert.
|
|
|
|
*/
|
2008-10-26 16:06:24 -06:00
|
|
|
ret = ocfs2_check_xattr_bucket_collision(inode,
|
2008-10-24 20:13:20 -06:00
|
|
|
xs->bucket,
|
2008-10-26 16:06:24 -06:00
|
|
|
xi->name);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_add_new_xattr_bucket(inode,
|
|
|
|
xs->xattr_bh,
|
2008-11-26 16:25:41 -07:00
|
|
|
xs->bucket,
|
2008-11-11 17:27:00 -07:00
|
|
|
ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-26 16:25:41 -07:00
|
|
|
/*
|
|
|
|
* ocfs2_add_new_xattr_bucket() will have updated
|
|
|
|
* xs->bucket if it moved, but it will not have updated
|
|
|
|
* any of the other search fields. Thus, we drop it and
|
|
|
|
* re-search. Everything should be cached, so it'll be
|
|
|
|
* quick.
|
|
|
|
*/
|
2008-10-24 20:13:20 -06:00
|
|
|
ocfs2_xattr_bucket_relse(xs->bucket);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,
|
|
|
|
xi->name_index,
|
|
|
|
xi->name, xs);
|
|
|
|
if (ret && ret != -ENODATA)
|
|
|
|
goto out;
|
|
|
|
xs->not_found = ret;
|
|
|
|
allocation = 1;
|
|
|
|
goto try_again;
|
|
|
|
}
|
|
|
|
|
|
|
|
xattr_set:
|
2008-11-11 17:27:00 -07:00
|
|
|
ret = ocfs2_xattr_set_in_bucket(inode, xi, xs, ctxt);
|
ocfs2: Enable xattr set in index btree
Where the previous patches added the ability of list/get xattr in buckets
for ocfs2, this patch enables ocfs2 to store large numbers of EAs.
The original design doc is written by Mark Fasheh, and it can be found in
http://oss.oracle.com/osswiki/OCFS2/DesignDocs/IndexedEATrees. I only had to
make small modifications to it.
First, because the bucket size is 4K, a new field named xh_free_start is added
in ocfs2_xattr_header to indicate the next valid name/value offset in a bucket.
It is used when we store new EA name/value. With this field, we can find the
place more quickly and what's more, we don't need to sort the name/value every
time to let the last entry indicate the next unused space. This makes the
insert operation more efficient for blocksizes smaller than 4k.
Because of the new xh_free_start, another field named as xh_name_value_len is
also added in ocfs2_xattr_header. It records the total length of all the
name/values in the bucket. We need this so that we can check it and defragment
the bucket if there is not enough contiguous free space.
An xattr insertion looks like this:
1. xattr_index_block_find: find the right bucket by the name_hash, say bucketA.
2. check whether there is enough space in bucketA. If yes, insert it directly
and modify xh_free_start and xh_name_value_len accordingly. If not, check
xh_name_value_len to see whether we can store this by defragment the bucket.
If yes, defragment it and go on insertion.
3. If defragement doesn't work, check whether there is new empty bucket in
the clusters within this extent record. If yes, init the new bucket and move
all the buckets after bucketA one by one to the next bucket. Move half of the
entries in bucketA to the next bucket and go on insertion.
4. If there is no new bucket, grow the extent tree.
As for xattr deletion, we will delete an xattr bucket when all it's xattrs
are removed and move all the buckets after it to the previous one. When all
the xattr buckets in an extend record are freed, free this extend records
from ocfs2_xattr_tree.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-08-18 03:38:53 -06:00
|
|
|
out:
|
|
|
|
mlog_exit(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-08-18 03:38:54 -06:00
|
|
|
|
|
|
|
static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
void *para)
|
|
|
|
{
|
2009-08-17 21:43:59 -06:00
|
|
|
int ret = 0, ref_credits;
|
2008-10-24 18:04:49 -06:00
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
2008-08-18 03:38:54 -06:00
|
|
|
u16 i;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
2008-11-11 17:27:00 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct ocfs2_xattr_set_ctxt ctxt = {NULL, NULL,};
|
2008-11-24 20:32:13 -07:00
|
|
|
int credits = ocfs2_remove_extent_credits(osb->sb) +
|
|
|
|
ocfs2_blocks_per_xattr_bucket(inode->i_sb);
|
2009-08-17 21:43:59 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv;
|
|
|
|
struct ocfs2_rm_xattr_bucket_para *args =
|
|
|
|
(struct ocfs2_rm_xattr_bucket_para *)para;
|
2008-11-11 17:27:00 -07:00
|
|
|
|
|
|
|
ocfs2_init_dealloc_ctxt(&ctxt.dealloc);
|
2008-08-18 03:38:54 -06:00
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
continue;
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,
|
|
|
|
i, &xv, NULL);
|
|
|
|
|
|
|
|
ret = ocfs2_lock_xattr_remove_allocators(inode, xv,
|
|
|
|
args->ref_ci,
|
|
|
|
args->ref_root_bh,
|
|
|
|
&ctxt.meta_ac,
|
|
|
|
&ref_credits);
|
|
|
|
|
|
|
|
ctxt.handle = ocfs2_start_trans(osb, credits + ref_credits);
|
2008-12-10 17:54:11 -07:00
|
|
|
if (IS_ERR(ctxt.handle)) {
|
|
|
|
ret = PTR_ERR(ctxt.handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-11-24 20:32:13 -07:00
|
|
|
ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,
|
2008-11-11 17:27:00 -07:00
|
|
|
i, 0, &ctxt);
|
2008-12-10 17:54:11 -07:00
|
|
|
|
|
|
|
ocfs2_commit_trans(osb, ctxt.handle);
|
2009-08-17 21:43:59 -06:00
|
|
|
if (ctxt.meta_ac) {
|
|
|
|
ocfs2_free_alloc_context(ctxt.meta_ac);
|
|
|
|
ctxt.meta_ac = NULL;
|
|
|
|
}
|
2008-08-18 03:38:54 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:59 -06:00
|
|
|
if (ctxt.meta_ac)
|
|
|
|
ocfs2_free_alloc_context(ctxt.meta_ac);
|
2008-11-11 17:27:00 -07:00
|
|
|
ocfs2_schedule_truncate_log_flush(osb, 1);
|
|
|
|
ocfs2_run_deallocs(osb, &ctxt.dealloc);
|
2008-08-18 03:38:54 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:17 -06:00
|
|
|
/*
|
|
|
|
* Whenever we modify a xattr value root in the bucket(e.g, CoW
|
|
|
|
* or change the extent record flag), we need to recalculate
|
|
|
|
* the metaecc for the whole bucket. So it is done here.
|
|
|
|
*
|
|
|
|
* Note:
|
|
|
|
* We have to give the extra credits for the caller.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_bucket_post_refcount(struct inode *inode,
|
|
|
|
handle_t *handle,
|
|
|
|
void *para)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_xattr_bucket *bucket =
|
|
|
|
(struct ocfs2_xattr_bucket *)para;
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle, bucket,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, bucket);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Special action we need if the xattr value is refcounted.
|
|
|
|
*
|
|
|
|
* 1. If the xattr is refcounted, lock the tree.
|
|
|
|
* 2. CoW the xattr if we are setting the new value and the value
|
|
|
|
* will be stored outside.
|
|
|
|
* 3. In other case, decrease_refcount will work for us, so just
|
|
|
|
* lock the refcount tree, calculate the meta and credits is OK.
|
|
|
|
*
|
|
|
|
* We have to do CoW before ocfs2_init_xattr_set_ctxt since
|
|
|
|
* currently CoW is a completed transaction, while this function
|
|
|
|
* will also lock the allocators and let us deadlock. So we will
|
|
|
|
* CoW the whole xattr value.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ocfs2_xattr_block *xb;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
char *base;
|
|
|
|
u32 p_cluster, num_clusters;
|
|
|
|
unsigned int ext_flags;
|
|
|
|
int name_offset, name_len;
|
|
|
|
struct ocfs2_xattr_value_buf vb;
|
|
|
|
struct ocfs2_xattr_bucket *bucket = NULL;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct ocfs2_post_refcount refcount;
|
|
|
|
struct ocfs2_post_refcount *p = NULL;
|
|
|
|
struct buffer_head *ref_root_bh = NULL;
|
|
|
|
|
|
|
|
if (!xis->not_found) {
|
|
|
|
xe = xis->here;
|
|
|
|
name_offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
base = xis->base;
|
|
|
|
vb.vb_bh = xis->inode_bh;
|
|
|
|
vb.vb_access = ocfs2_journal_access_di;
|
|
|
|
} else {
|
|
|
|
int i, block_off = 0;
|
|
|
|
xb = (struct ocfs2_xattr_block *)xbs->xattr_bh->b_data;
|
|
|
|
xe = xbs->here;
|
|
|
|
name_offset = le16_to_cpu(xe->xe_name_offset);
|
|
|
|
name_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
|
|
|
|
i = xbs->here - xbs->header->xh_entries;
|
|
|
|
|
|
|
|
if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
|
2009-08-17 21:43:21 -06:00
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb,
|
2009-08-17 21:43:17 -06:00
|
|
|
bucket_xh(xbs->bucket),
|
|
|
|
i, &block_off,
|
|
|
|
&name_offset);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
base = bucket_block(xbs->bucket, block_off);
|
|
|
|
vb.vb_bh = xbs->bucket->bu_bhs[block_off];
|
|
|
|
vb.vb_access = ocfs2_journal_access;
|
|
|
|
|
|
|
|
if (ocfs2_meta_ecc(osb)) {
|
|
|
|
/*create parameters for ocfs2_post_refcount. */
|
|
|
|
bucket = xbs->bucket;
|
|
|
|
refcount.credits = bucket->bu_blocks;
|
|
|
|
refcount.para = bucket;
|
|
|
|
refcount.func =
|
|
|
|
ocfs2_xattr_bucket_post_refcount;
|
|
|
|
p = &refcount;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
base = xbs->base;
|
|
|
|
vb.vb_bh = xbs->xattr_bh;
|
|
|
|
vb.vb_access = ocfs2_journal_access_xb;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
vb.vb_xv = (struct ocfs2_xattr_value_root *)
|
|
|
|
(base + name_offset + name_len);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, 0, &p_cluster,
|
|
|
|
&num_clusters, &vb.vb_xv->xr_list,
|
|
|
|
&ext_flags);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We just need to check the 1st extent record, since we always
|
|
|
|
* CoW the whole xattr. So there shouldn't be a xattr with
|
|
|
|
* some REFCOUNT extent recs after the 1st one.
|
|
|
|
*/
|
|
|
|
if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
|
|
|
|
1, ref_tree, &ref_root_bh);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are deleting the xattr or the new size will be stored inside,
|
|
|
|
* cool, leave it there, the xattr truncate process will remove them
|
|
|
|
* for us(it still needs the refcount tree lock and the meta, credits).
|
|
|
|
* And the worse case is that every cluster truncate will split the
|
|
|
|
* refcount tree, and make the original extent become 3. So we will need
|
|
|
|
* 2 * cluster more extent recs at most.
|
|
|
|
*/
|
|
|
|
if (!xi->value || xi->value_len <= OCFS2_XATTR_INLINE_SIZE) {
|
|
|
|
|
|
|
|
ret = ocfs2_refcounted_xattr_delete_need(inode,
|
|
|
|
&(*ref_tree)->rf_ci,
|
|
|
|
ref_root_bh, vb.vb_xv,
|
|
|
|
meta_add, credits);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_refcount_cow_xattr(inode, di, &vb,
|
|
|
|
*ref_tree, ref_root_bh, 0,
|
|
|
|
le32_to_cpu(vb.vb_xv->xr_clusters), p);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
brelse(ref_root_bh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-09-20 23:04:19 -06:00
|
|
|
/*
|
|
|
|
* Add the REFCOUNTED flags for all the extent rec in ocfs2_xattr_value_root.
|
|
|
|
* The physical clusters will be added to refcount tree.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 clusters = le32_to_cpu(xv->xr_clusters);
|
|
|
|
u32 cpos, p_cluster, num_clusters;
|
|
|
|
struct ocfs2_extent_list *el = &xv->xr_list;
|
|
|
|
unsigned int ext_flags;
|
|
|
|
|
|
|
|
cpos = 0;
|
|
|
|
while (cpos < clusters) {
|
|
|
|
ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
|
|
|
|
&num_clusters, el, &ext_flags);
|
|
|
|
|
|
|
|
cpos += num_clusters;
|
|
|
|
if ((ext_flags & OCFS2_EXT_REFCOUNTED))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
BUG_ON(!p_cluster);
|
|
|
|
|
|
|
|
ret = ocfs2_add_refcount_flag(inode, value_et,
|
|
|
|
ref_ci, ref_root_bh,
|
|
|
|
cpos - num_clusters,
|
|
|
|
p_cluster, num_clusters,
|
|
|
|
dealloc, refcount);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a normal ocfs2_xattr_header, refcount all the entries which
|
|
|
|
* have value stored outside.
|
|
|
|
* Used for xattrs stored in inode and ocfs2_xattr_block.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
struct ocfs2_xattr_value_root *xv;
|
|
|
|
struct ocfs2_extent_tree et;
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
|
|
|
|
xe = &header->xh_entries[i];
|
|
|
|
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
xv = (struct ocfs2_xattr_value_root *)((void *)header +
|
|
|
|
le16_to_cpu(xe->xe_name_offset) +
|
|
|
|
OCFS2_XATTR_SIZE(xe->xe_name_len));
|
|
|
|
|
|
|
|
vb->vb_xv = xv;
|
|
|
|
ocfs2_init_xattr_value_extent_tree(&et, INODE_CACHE(inode), vb);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_value_attach_refcount(inode, xv, &et,
|
|
|
|
ref_ci, ref_root_bh,
|
|
|
|
dealloc, NULL);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
|
|
|
|
struct ocfs2_xattr_header *header = (struct ocfs2_xattr_header *)
|
|
|
|
(fe_bh->b_data + inode->i_sb->s_blocksize -
|
|
|
|
le16_to_cpu(di->i_xattr_inline_size));
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = fe_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_di,
|
|
|
|
};
|
|
|
|
|
|
|
|
return ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
|
|
|
|
ref_ci, ref_root_bh, dealloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ocfs2_xattr_tree_value_refcount_para {
|
|
|
|
struct ocfs2_caching_info *ref_ci;
|
|
|
|
struct buffer_head *ref_root_bh;
|
|
|
|
struct ocfs2_cached_dealloc_ctxt *dealloc;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret, block_off, name_offset;
|
|
|
|
struct ocfs2_xattr_header *xh = bucket_xh(bucket);
|
|
|
|
struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
|
|
|
|
void *base;
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_get_name_value(sb,
|
|
|
|
bucket_xh(bucket),
|
|
|
|
offset,
|
|
|
|
&block_off,
|
|
|
|
&name_offset);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
base = bucket_block(bucket, block_off);
|
|
|
|
|
|
|
|
*xv = (struct ocfs2_xattr_value_root *)(base + name_offset +
|
|
|
|
OCFS2_XATTR_SIZE(xe->xe_name_len));
|
|
|
|
|
|
|
|
if (bh)
|
|
|
|
*bh = bucket->bu_bhs[block_off];
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For a given xattr bucket, refcount all the entries which
|
|
|
|
* have value stored outside.
|
|
|
|
*/
|
|
|
|
static int ocfs2_xattr_bucket_value_refcount(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
void *para)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
struct ocfs2_extent_tree et;
|
|
|
|
struct ocfs2_xattr_tree_value_refcount_para *ref =
|
|
|
|
(struct ocfs2_xattr_tree_value_refcount_para *)para;
|
|
|
|
struct ocfs2_xattr_header *xh =
|
|
|
|
(struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_access = ocfs2_journal_access,
|
|
|
|
};
|
|
|
|
struct ocfs2_post_refcount refcount = {
|
|
|
|
.credits = bucket->bu_blocks,
|
|
|
|
.para = bucket,
|
|
|
|
.func = ocfs2_xattr_bucket_post_refcount,
|
|
|
|
};
|
|
|
|
struct ocfs2_post_refcount *p = NULL;
|
|
|
|
|
|
|
|
/* We only need post_refcount if we support metaecc. */
|
|
|
|
if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb)))
|
|
|
|
p = &refcount;
|
|
|
|
|
|
|
|
mlog(0, "refcount bucket %llu, count = %u\n",
|
|
|
|
(unsigned long long)bucket_blkno(bucket),
|
|
|
|
le16_to_cpu(xh->xh_count));
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i,
|
|
|
|
&vb.vb_xv, &vb.vb_bh);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_init_xattr_value_extent_tree(&et,
|
|
|
|
INODE_CACHE(inode), &vb);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_value_attach_refcount(inode, vb.vb_xv,
|
|
|
|
&et, ref->ref_ci,
|
|
|
|
ref->ref_root_bh,
|
|
|
|
ref->dealloc, p);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_refcount_xattr_tree_rec(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno, u32 cpos, u32 len, void *para)
|
|
|
|
{
|
|
|
|
return ocfs2_iterate_xattr_buckets(inode, blkno, len,
|
|
|
|
ocfs2_xattr_bucket_value_refcount,
|
|
|
|
para);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)blk_bh->b_data;
|
|
|
|
|
|
|
|
if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
|
|
|
|
struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = blk_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_xb,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_attach_refcount_normal(inode, &vb, header,
|
|
|
|
ref_ci, ref_root_bh,
|
|
|
|
dealloc);
|
|
|
|
} else {
|
|
|
|
struct ocfs2_xattr_tree_value_refcount_para para = {
|
|
|
|
.ref_ci = ref_ci,
|
|
|
|
.ref_root_bh = ref_root_bh,
|
|
|
|
.dealloc = dealloc,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_iterate_xattr_index_block(inode, blk_bh,
|
|
|
|
ocfs2_refcount_xattr_tree_rec,
|
|
|
|
¶);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int 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)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
|
|
|
|
struct buffer_head *blk_bh = NULL;
|
|
|
|
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
|
|
|
|
ret = ocfs2_xattr_inline_attach_refcount(inode, fe_bh,
|
|
|
|
ref_ci, ref_root_bh,
|
|
|
|
dealloc);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!di->i_xattr_loc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ocfs2_read_xattr_block(inode, le64_to_cpu(di->i_xattr_loc),
|
|
|
|
&blk_bh);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_block_attach_refcount(inode, blk_bh, ref_ci,
|
|
|
|
ref_root_bh, dealloc);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
brelse(blk_bh);
|
|
|
|
out:
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:47:56 -06:00
|
|
|
typedef int (should_xattr_reflinked)(struct ocfs2_xattr_entry *xe);
|
2009-08-17 21:43:55 -06:00
|
|
|
/*
|
|
|
|
* Store the information we need in xattr reflink.
|
|
|
|
* old_bh and new_bh are inode bh for the old and new inode.
|
|
|
|
*/
|
|
|
|
struct ocfs2_xattr_reflink {
|
|
|
|
struct inode *old_inode;
|
|
|
|
struct inode *new_inode;
|
|
|
|
struct buffer_head *old_bh;
|
|
|
|
struct buffer_head *new_bh;
|
|
|
|
struct ocfs2_caching_info *ref_ci;
|
|
|
|
struct buffer_head *ref_root_bh;
|
|
|
|
struct ocfs2_cached_dealloc_ctxt *dealloc;
|
2009-08-17 21:47:56 -06:00
|
|
|
should_xattr_reflinked *xattr_reflinked;
|
2009-08-17 21:43:55 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a xattr header and xe offset,
|
|
|
|
* return the proper xv and the corresponding bh.
|
|
|
|
* xattr in inode, block and xattr tree have different implementaions.
|
|
|
|
*/
|
|
|
|
typedef int (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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate all the xattr value root metadata stored in this xattr header and
|
|
|
|
* credits we need if we create them from the scratch.
|
|
|
|
* We use get_xattr_value_root so that all types of xattr container can use it.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
struct ocfs2_xattr_value_root *xv;
|
|
|
|
struct ocfs2_xattr_entry *xe;
|
|
|
|
|
|
|
|
for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
|
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = func(sb, bh, xh, i, &xv, NULL, para);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*metas += le16_to_cpu(xv->xr_list.l_tree_depth) *
|
|
|
|
le16_to_cpu(xv->xr_list.l_next_free_rec);
|
|
|
|
|
|
|
|
*credits += ocfs2_calc_extend_credits(sb,
|
|
|
|
&def_xv.xv.xr_list,
|
|
|
|
le32_to_cpu(xv->xr_clusters));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the value is a tree with depth > 1, We don't go deep
|
|
|
|
* to the extent block, so just calculate a maximum record num.
|
|
|
|
*/
|
|
|
|
if (!xv->xr_list.l_tree_depth)
|
2009-12-22 23:31:15 -07:00
|
|
|
*num_recs += le16_to_cpu(xv->xr_list.l_next_free_rec);
|
2009-08-17 21:43:55 -06:00
|
|
|
else
|
|
|
|
*num_recs += ocfs2_clusters_for_bytes(sb,
|
|
|
|
XATTR_SIZE_MAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Used by xattr inode and block to return the right xv and buffer_head. */
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_entry *xe = &xh->xh_entries[offset];
|
|
|
|
|
|
|
|
*xv = (struct ocfs2_xattr_value_root *)((void *)xh +
|
|
|
|
le16_to_cpu(xe->xe_name_offset) +
|
|
|
|
OCFS2_XATTR_SIZE(xe->xe_name_len));
|
|
|
|
|
|
|
|
if (ret_bh)
|
|
|
|
*ret_bh = bh;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock the meta_ac and caculate how much credits we need for reflink xattrs.
|
|
|
|
* It is only used for inline xattr and xattr block.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret, meta_add = 0, num_recs = 0;
|
|
|
|
struct ocfs2_refcount_block *rb =
|
|
|
|
(struct ocfs2_refcount_block *)ref_root_bh->b_data;
|
|
|
|
|
|
|
|
*credits = 0;
|
|
|
|
|
|
|
|
ret = ocfs2_value_metas_in_xattr_header(osb->sb, NULL, xh,
|
|
|
|
&meta_add, credits, &num_recs,
|
|
|
|
ocfs2_get_xattr_value_root,
|
|
|
|
NULL);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to add/modify num_recs in refcount tree, so just calculate
|
|
|
|
* an approximate number we need for refcount tree change.
|
|
|
|
* Sometimes we need to split the tree, and after split, half recs
|
|
|
|
* will be moved to the new block, and a new block can only provide
|
|
|
|
* half number of recs. So we multiple new blocks by 2.
|
|
|
|
*/
|
|
|
|
num_recs = num_recs / ocfs2_refcount_recs_per_rb(osb->sb) * 2;
|
|
|
|
meta_add += num_recs;
|
|
|
|
*credits += num_recs + num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
|
|
|
|
if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
|
|
|
|
*credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
|
|
|
|
le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
|
|
|
|
else
|
|
|
|
*credits += 1;
|
|
|
|
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(osb, meta_add, meta_ac);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a xattr header, reflink all the xattrs in this container.
|
|
|
|
* It can be used for inode, block and bucket.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
* Before we call this function, the caller has memcpy the xattr in
|
|
|
|
* old_xh to the new_xh.
|
2009-08-17 21:47:56 -06:00
|
|
|
*
|
|
|
|
* If args.xattr_reflinked is set, call it to decide whether the xe should
|
|
|
|
* be reflinked or not. If not, remove it from the new xattr header.
|
2009-08-17 21:43:55 -06:00
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
2009-08-17 21:47:56 -06:00
|
|
|
int ret = 0, i, j;
|
2009-08-17 21:43:55 -06:00
|
|
|
struct super_block *sb = args->old_inode->i_sb;
|
|
|
|
struct buffer_head *value_bh;
|
2009-08-17 21:47:56 -06:00
|
|
|
struct ocfs2_xattr_entry *xe, *last;
|
2009-08-17 21:43:55 -06:00
|
|
|
struct ocfs2_xattr_value_root *xv, *new_xv;
|
|
|
|
struct ocfs2_extent_tree data_et;
|
|
|
|
u32 clusters, cpos, p_cluster, num_clusters;
|
|
|
|
unsigned int ext_flags = 0;
|
|
|
|
|
|
|
|
mlog(0, "reflink xattr in container %llu, count = %u\n",
|
|
|
|
(unsigned long long)old_bh->b_blocknr, le16_to_cpu(xh->xh_count));
|
2009-08-17 21:47:56 -06:00
|
|
|
|
|
|
|
last = &new_xh->xh_entries[le16_to_cpu(new_xh->xh_count)];
|
|
|
|
for (i = 0, j = 0; i < le16_to_cpu(xh->xh_count); i++, j++) {
|
2009-08-17 21:43:55 -06:00
|
|
|
xe = &xh->xh_entries[i];
|
|
|
|
|
2009-08-17 21:47:56 -06:00
|
|
|
if (args->xattr_reflinked && !args->xattr_reflinked(xe)) {
|
|
|
|
xe = &new_xh->xh_entries[j];
|
|
|
|
|
|
|
|
le16_add_cpu(&new_xh->xh_count, -1);
|
|
|
|
if (new_xh->xh_count) {
|
|
|
|
memmove(xe, xe + 1,
|
|
|
|
(void *)last - (void *)xe);
|
|
|
|
memset(last, 0,
|
|
|
|
sizeof(struct ocfs2_xattr_entry));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't want j to increase in the next round since
|
|
|
|
* it is already moved ahead.
|
|
|
|
*/
|
|
|
|
j--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:55 -06:00
|
|
|
if (ocfs2_xattr_is_local(xe))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = func(sb, old_bh, xh, i, &xv, NULL, para);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:47:56 -06:00
|
|
|
ret = func(sb, new_bh, new_xh, j, &new_xv, &value_bh, para);
|
2009-08-17 21:43:55 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For the xattr which has l_tree_depth = 0, all the extent
|
|
|
|
* recs have already be copied to the new xh with the
|
|
|
|
* propriate OCFS2_EXT_REFCOUNTED flag we just need to
|
|
|
|
* increase the refount count int the refcount tree.
|
|
|
|
*
|
|
|
|
* For the xattr which has l_tree_depth > 0, we need
|
|
|
|
* to initialize it to the empty default value root,
|
|
|
|
* and then insert the extents one by one.
|
|
|
|
*/
|
|
|
|
if (xv->xr_list.l_tree_depth) {
|
|
|
|
memcpy(new_xv, &def_xv, sizeof(def_xv));
|
|
|
|
vb->vb_xv = new_xv;
|
|
|
|
vb->vb_bh = value_bh;
|
|
|
|
ocfs2_init_xattr_value_extent_tree(&data_et,
|
|
|
|
INODE_CACHE(args->new_inode), vb);
|
|
|
|
}
|
|
|
|
|
|
|
|
clusters = le32_to_cpu(xv->xr_clusters);
|
|
|
|
cpos = 0;
|
|
|
|
while (cpos < clusters) {
|
|
|
|
ret = ocfs2_xattr_get_clusters(args->old_inode,
|
|
|
|
cpos,
|
|
|
|
&p_cluster,
|
|
|
|
&num_clusters,
|
|
|
|
&xv->xr_list,
|
|
|
|
&ext_flags);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(!p_cluster);
|
|
|
|
|
|
|
|
if (xv->xr_list.l_tree_depth) {
|
|
|
|
ret = ocfs2_insert_extent(handle,
|
|
|
|
&data_et, cpos,
|
|
|
|
ocfs2_clusters_to_blocks(
|
|
|
|
args->old_inode->i_sb,
|
|
|
|
p_cluster),
|
|
|
|
num_clusters, ext_flags,
|
|
|
|
meta_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_increase_refcount(handle, args->ref_ci,
|
|
|
|
args->ref_root_bh,
|
|
|
|
p_cluster, num_clusters,
|
|
|
|
meta_ac, args->dealloc);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpos += num_clusters;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_reflink_xattr_inline(struct ocfs2_xattr_reflink *args)
|
|
|
|
{
|
|
|
|
int ret = 0, credits = 0;
|
|
|
|
handle_t *handle;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)args->old_bh->b_data;
|
|
|
|
int inline_size = le16_to_cpu(di->i_xattr_inline_size);
|
|
|
|
int header_off = osb->sb->s_blocksize - inline_size;
|
|
|
|
struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)
|
|
|
|
(args->old_bh->b_data + header_off);
|
|
|
|
struct ocfs2_xattr_header *new_xh = (struct ocfs2_xattr_header *)
|
|
|
|
(args->new_bh->b_data + header_off);
|
|
|
|
struct ocfs2_alloc_context *meta_ac = NULL;
|
|
|
|
struct ocfs2_inode_info *new_oi;
|
|
|
|
struct ocfs2_dinode *new_di;
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = args->new_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_di,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
|
|
|
|
&credits, &meta_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
handle = ocfs2_start_trans(osb, credits);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_journal_access_di(handle, INODE_CACHE(args->new_inode),
|
|
|
|
args->new_bh, OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(args->new_bh->b_data + header_off,
|
|
|
|
args->old_bh->b_data + header_off, inline_size);
|
|
|
|
|
|
|
|
new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
|
|
|
|
new_di->i_xattr_inline_size = cpu_to_le16(inline_size);
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_xattr_header(handle, args, args->old_bh, xh,
|
|
|
|
args->new_bh, new_xh, &vb, meta_ac,
|
|
|
|
ocfs2_get_xattr_value_root, NULL);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_oi = OCFS2_I(args->new_inode);
|
|
|
|
spin_lock(&new_oi->ip_lock);
|
|
|
|
new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL | OCFS2_INLINE_XATTR_FL;
|
|
|
|
new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
|
|
|
|
spin_unlock(&new_oi->ip_lock);
|
|
|
|
|
|
|
|
ocfs2_journal_dirty(handle, args->new_bh);
|
|
|
|
|
|
|
|
out_commit:
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (meta_ac)
|
|
|
|
ocfs2_free_alloc_context(meta_ac);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_create_empty_xattr_block(struct inode *inode,
|
|
|
|
struct buffer_head *fe_bh,
|
|
|
|
struct buffer_head **ret_bh,
|
|
|
|
int indexed)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
handle_t *handle;
|
|
|
|
struct ocfs2_alloc_context *meta_ac;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_CREATE_CREDITS);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlog(0, "create new xattr block for inode %llu, index = %d\n",
|
|
|
|
(unsigned long long)fe_bh->b_blocknr, indexed);
|
|
|
|
ret = ocfs2_create_xattr_block(handle, inode, fe_bh,
|
|
|
|
meta_ac, ret_bh, indexed);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
out:
|
|
|
|
ocfs2_free_alloc_context(meta_ac);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_reflink_xattr_block(struct ocfs2_xattr_reflink *args,
|
|
|
|
struct buffer_head *blk_bh,
|
|
|
|
struct buffer_head *new_blk_bh)
|
|
|
|
{
|
|
|
|
int ret = 0, credits = 0;
|
|
|
|
handle_t *handle;
|
|
|
|
struct ocfs2_inode_info *new_oi = OCFS2_I(args->new_inode);
|
|
|
|
struct ocfs2_dinode *new_di;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb);
|
|
|
|
int header_off = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)blk_bh->b_data;
|
|
|
|
struct ocfs2_xattr_header *xh = &xb->xb_attrs.xb_header;
|
|
|
|
struct ocfs2_xattr_block *new_xb =
|
|
|
|
(struct ocfs2_xattr_block *)new_blk_bh->b_data;
|
|
|
|
struct ocfs2_xattr_header *new_xh = &new_xb->xb_attrs.xb_header;
|
|
|
|
struct ocfs2_alloc_context *meta_ac;
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_bh = new_blk_bh,
|
|
|
|
.vb_access = ocfs2_journal_access_xb,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_lock_xattr_allocators(osb, xh, args->ref_root_bh,
|
|
|
|
&credits, &meta_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* One more credits in case we need to add xattr flags in new inode. */
|
|
|
|
handle = ocfs2_start_trans(osb, credits + 1);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
|
|
|
|
ret = ocfs2_journal_access_di(handle,
|
|
|
|
INODE_CACHE(args->new_inode),
|
|
|
|
args->new_bh,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_journal_access_xb(handle, INODE_CACHE(args->new_inode),
|
|
|
|
new_blk_bh, OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(new_blk_bh->b_data + header_off, blk_bh->b_data + header_off,
|
|
|
|
osb->sb->s_blocksize - header_off);
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_xattr_header(handle, args, blk_bh, xh,
|
|
|
|
new_blk_bh, new_xh, &vb, meta_ac,
|
|
|
|
ocfs2_get_xattr_value_root, NULL);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_journal_dirty(handle, new_blk_bh);
|
|
|
|
|
|
|
|
if (!(new_oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) {
|
|
|
|
new_di = (struct ocfs2_dinode *)args->new_bh->b_data;
|
|
|
|
spin_lock(&new_oi->ip_lock);
|
|
|
|
new_oi->ip_dyn_features |= OCFS2_HAS_XATTR_FL;
|
|
|
|
new_di->i_dyn_features = cpu_to_le16(new_oi->ip_dyn_features);
|
|
|
|
spin_unlock(&new_oi->ip_lock);
|
|
|
|
|
|
|
|
ocfs2_journal_dirty(handle, args->new_bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
out_commit:
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
|
|
|
|
out:
|
|
|
|
ocfs2_free_alloc_context(meta_ac);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ocfs2_reflink_xattr_tree_args {
|
|
|
|
struct ocfs2_xattr_reflink *reflink;
|
|
|
|
struct buffer_head *old_blk_bh;
|
|
|
|
struct buffer_head *new_blk_bh;
|
|
|
|
struct ocfs2_xattr_bucket *old_bucket;
|
|
|
|
struct ocfs2_xattr_bucket *new_bucket;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE:
|
|
|
|
* We have to handle the case that both old bucket and new bucket
|
|
|
|
* will call this function to get the right ret_bh.
|
|
|
|
* So The caller must give us the right bh.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
struct ocfs2_reflink_xattr_tree_args *args =
|
|
|
|
(struct ocfs2_reflink_xattr_tree_args *)para;
|
|
|
|
struct ocfs2_xattr_bucket *bucket;
|
|
|
|
|
|
|
|
if (bh == args->old_bucket->bu_bhs[0])
|
|
|
|
bucket = args->old_bucket;
|
|
|
|
else
|
|
|
|
bucket = args->new_bucket;
|
|
|
|
|
|
|
|
return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
|
|
|
|
xv, ret_bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ocfs2_value_tree_metas {
|
|
|
|
int num_metas;
|
|
|
|
int credits;
|
|
|
|
int num_recs;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
struct ocfs2_xattr_bucket *bucket =
|
|
|
|
(struct ocfs2_xattr_bucket *)para;
|
|
|
|
|
|
|
|
return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,
|
|
|
|
xv, ret_bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_calc_value_tree_metas(struct inode *inode,
|
|
|
|
struct ocfs2_xattr_bucket *bucket,
|
|
|
|
void *para)
|
|
|
|
{
|
|
|
|
struct ocfs2_value_tree_metas *metas =
|
|
|
|
(struct ocfs2_value_tree_metas *)para;
|
|
|
|
struct ocfs2_xattr_header *xh =
|
|
|
|
(struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;
|
|
|
|
|
|
|
|
/* Add the credits for this bucket first. */
|
|
|
|
metas->credits += bucket->bu_blocks;
|
|
|
|
return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0],
|
|
|
|
xh, &metas->num_metas,
|
|
|
|
&metas->credits, &metas->num_recs,
|
|
|
|
ocfs2_value_tree_metas_in_bucket,
|
|
|
|
bucket);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a xattr extent rec starting from blkno and having len clusters,
|
|
|
|
* iterate all the buckets calculate how much metadata we need for reflinking
|
|
|
|
* all the ocfs2_xattr_value_root and lock the allocators accordingly.
|
|
|
|
*/
|
|
|
|
static int 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)
|
|
|
|
{
|
|
|
|
int ret, num_free_extents;
|
|
|
|
struct ocfs2_value_tree_metas metas;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb);
|
|
|
|
struct ocfs2_refcount_block *rb;
|
|
|
|
|
|
|
|
memset(&metas, 0, sizeof(metas));
|
|
|
|
|
|
|
|
ret = ocfs2_iterate_xattr_buckets(args->reflink->old_inode, blkno, len,
|
|
|
|
ocfs2_calc_value_tree_metas, &metas);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
*credits = metas.credits;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate we need for refcount tree change.
|
|
|
|
*
|
|
|
|
* We need to add/modify num_recs in refcount tree, so just calculate
|
|
|
|
* an approximate number we need for refcount tree change.
|
|
|
|
* Sometimes we need to split the tree, and after split, half recs
|
|
|
|
* will be moved to the new block, and a new block can only provide
|
|
|
|
* half number of recs. So we multiple new blocks by 2.
|
|
|
|
* In the end, we have to add credits for modifying the already
|
|
|
|
* existed refcount block.
|
|
|
|
*/
|
|
|
|
rb = (struct ocfs2_refcount_block *)args->reflink->ref_root_bh->b_data;
|
|
|
|
metas.num_recs =
|
|
|
|
(metas.num_recs + ocfs2_refcount_recs_per_rb(osb->sb) - 1) /
|
|
|
|
ocfs2_refcount_recs_per_rb(osb->sb) * 2;
|
|
|
|
metas.num_metas += metas.num_recs;
|
|
|
|
*credits += metas.num_recs +
|
|
|
|
metas.num_recs * OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
|
|
|
|
if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
|
|
|
|
*credits += le16_to_cpu(rb->rf_list.l_tree_depth) *
|
|
|
|
le16_to_cpu(rb->rf_list.l_next_free_rec) + 1;
|
|
|
|
else
|
|
|
|
*credits += 1;
|
|
|
|
|
|
|
|
/* count in the xattr tree change. */
|
|
|
|
num_free_extents = ocfs2_num_free_extents(osb, xt_et);
|
|
|
|
if (num_free_extents < 0) {
|
|
|
|
ret = num_free_extents;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_free_extents < len)
|
|
|
|
metas.num_metas += ocfs2_extend_meta_needed(xt_et->et_root_el);
|
|
|
|
|
|
|
|
*credits += ocfs2_calc_extend_credits(osb->sb,
|
|
|
|
xt_et->et_root_el, len);
|
|
|
|
|
|
|
|
if (metas.num_metas) {
|
|
|
|
ret = ocfs2_reserve_new_metadata_blocks(osb, metas.num_metas,
|
|
|
|
meta_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len) {
|
|
|
|
ret = ocfs2_reserve_clusters(osb, len, data_ac);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (ret) {
|
|
|
|
if (*meta_ac) {
|
|
|
|
ocfs2_free_alloc_context(*meta_ac);
|
|
|
|
meta_ac = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_reflink_xattr_buckets(handle_t *handle,
|
|
|
|
u64 blkno, u64 new_blkno, u32 clusters,
|
|
|
|
struct ocfs2_alloc_context *meta_ac,
|
|
|
|
struct ocfs2_alloc_context *data_ac,
|
|
|
|
struct ocfs2_reflink_xattr_tree_args *args)
|
|
|
|
{
|
|
|
|
int i, j, ret = 0;
|
|
|
|
struct super_block *sb = args->reflink->old_inode->i_sb;
|
|
|
|
u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(sb));
|
|
|
|
u32 num_buckets = clusters * bpc;
|
|
|
|
int bpb = args->old_bucket->bu_blocks;
|
|
|
|
struct ocfs2_xattr_value_buf vb = {
|
|
|
|
.vb_access = ocfs2_journal_access,
|
|
|
|
};
|
|
|
|
|
|
|
|
for (i = 0; i < num_buckets; i++, blkno += bpb, new_blkno += bpb) {
|
|
|
|
ret = ocfs2_read_xattr_bucket(args->old_bucket, blkno);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_init_xattr_bucket(args->new_bucket, new_blkno);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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(args->old_bucket)->xh_num_buckets);
|
|
|
|
|
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle,
|
|
|
|
args->new_bucket,
|
|
|
|
OCFS2_JOURNAL_ACCESS_CREATE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < bpb; j++)
|
|
|
|
memcpy(bucket_block(args->new_bucket, j),
|
|
|
|
bucket_block(args->old_bucket, j),
|
|
|
|
sb->s_blocksize);
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_xattr_header(handle, args->reflink,
|
|
|
|
args->old_bucket->bu_bhs[0],
|
|
|
|
bucket_xh(args->old_bucket),
|
|
|
|
args->new_bucket->bu_bhs[0],
|
|
|
|
bucket_xh(args->new_bucket),
|
|
|
|
&vb, meta_ac,
|
|
|
|
ocfs2_get_reflink_xattr_value_root,
|
|
|
|
args);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Re-access and dirty the bucket to calculate metaecc.
|
|
|
|
* Because we may extend the transaction in reflink_xattr_header
|
|
|
|
* which will let the already accessed block gone.
|
|
|
|
*/
|
|
|
|
ret = ocfs2_xattr_bucket_journal_access(handle,
|
|
|
|
args->new_bucket,
|
|
|
|
OCFS2_JOURNAL_ACCESS_WRITE);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_journal_dirty(handle, args->new_bucket);
|
|
|
|
ocfs2_xattr_bucket_relse(args->old_bucket);
|
|
|
|
ocfs2_xattr_bucket_relse(args->new_bucket);
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_xattr_bucket_relse(args->old_bucket);
|
|
|
|
ocfs2_xattr_bucket_relse(args->new_bucket);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Create the same xattr extent record in the new inode's xattr tree.
|
|
|
|
*/
|
|
|
|
static int ocfs2_reflink_xattr_rec(struct inode *inode,
|
|
|
|
struct buffer_head *root_bh,
|
|
|
|
u64 blkno,
|
|
|
|
u32 cpos,
|
|
|
|
u32 len,
|
|
|
|
void *para)
|
|
|
|
{
|
|
|
|
int ret, credits = 0;
|
|
|
|
u32 p_cluster, num_clusters;
|
|
|
|
u64 new_blkno;
|
|
|
|
handle_t *handle;
|
|
|
|
struct ocfs2_reflink_xattr_tree_args *args =
|
|
|
|
(struct ocfs2_reflink_xattr_tree_args *)para;
|
|
|
|
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
|
|
|
|
struct ocfs2_alloc_context *meta_ac = NULL;
|
|
|
|
struct ocfs2_alloc_context *data_ac = NULL;
|
|
|
|
struct ocfs2_extent_tree et;
|
|
|
|
|
|
|
|
ocfs2_init_xattr_tree_extent_tree(&et,
|
|
|
|
INODE_CACHE(args->reflink->new_inode),
|
|
|
|
args->new_blk_bh);
|
|
|
|
|
|
|
|
ret = ocfs2_lock_reflink_xattr_rec_allocators(args, &et, blkno,
|
|
|
|
len, &credits,
|
|
|
|
&meta_ac, &data_ac);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
handle = ocfs2_start_trans(osb, credits);
|
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
ret = PTR_ERR(handle);
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_claim_clusters(osb, handle, data_ac,
|
|
|
|
len, &p_cluster, &num_clusters);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cluster);
|
|
|
|
|
|
|
|
mlog(0, "reflink xattr buckets %llu to %llu, len %u\n",
|
|
|
|
(unsigned long long)blkno, (unsigned long long)new_blkno, len);
|
|
|
|
ret = ocfs2_reflink_xattr_buckets(handle, blkno, new_blkno, len,
|
|
|
|
meta_ac, data_ac, args);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlog(0, "insert new xattr extent rec start %llu len %u to %u\n",
|
|
|
|
(unsigned long long)new_blkno, len, cpos);
|
|
|
|
ret = ocfs2_insert_extent(handle, &et, cpos, new_blkno,
|
|
|
|
len, 0, meta_ac);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out_commit:
|
|
|
|
ocfs2_commit_trans(osb, handle);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (meta_ac)
|
|
|
|
ocfs2_free_alloc_context(meta_ac);
|
|
|
|
if (data_ac)
|
|
|
|
ocfs2_free_alloc_context(data_ac);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create reflinked xattr buckets.
|
|
|
|
* We will add bucket one by one, and refcount all the xattrs in the bucket
|
|
|
|
* if they are stored outside.
|
|
|
|
*/
|
|
|
|
static int ocfs2_reflink_xattr_tree(struct ocfs2_xattr_reflink *args,
|
|
|
|
struct buffer_head *blk_bh,
|
|
|
|
struct buffer_head *new_blk_bh)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_reflink_xattr_tree_args para;
|
|
|
|
|
|
|
|
memset(¶, 0, sizeof(para));
|
|
|
|
para.reflink = args;
|
|
|
|
para.old_blk_bh = blk_bh;
|
|
|
|
para.new_blk_bh = new_blk_bh;
|
|
|
|
|
|
|
|
para.old_bucket = ocfs2_xattr_bucket_new(args->old_inode);
|
|
|
|
if (!para.old_bucket) {
|
|
|
|
mlog_errno(-ENOMEM);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
para.new_bucket = ocfs2_xattr_bucket_new(args->new_inode);
|
|
|
|
if (!para.new_bucket) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_iterate_xattr_index_block(args->old_inode, blk_bh,
|
|
|
|
ocfs2_reflink_xattr_rec,
|
|
|
|
¶);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
ocfs2_xattr_bucket_free(para.old_bucket);
|
|
|
|
ocfs2_xattr_bucket_free(para.new_bucket);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ocfs2_reflink_xattr_in_block(struct ocfs2_xattr_reflink *args,
|
|
|
|
struct buffer_head *blk_bh)
|
|
|
|
{
|
|
|
|
int ret, indexed = 0;
|
|
|
|
struct buffer_head *new_blk_bh = NULL;
|
|
|
|
struct ocfs2_xattr_block *xb =
|
|
|
|
(struct ocfs2_xattr_block *)blk_bh->b_data;
|
|
|
|
|
|
|
|
|
|
|
|
if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)
|
|
|
|
indexed = 1;
|
|
|
|
|
|
|
|
ret = ocfs2_create_empty_xattr_block(args->new_inode, args->new_bh,
|
|
|
|
&new_blk_bh, indexed);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED))
|
|
|
|
ret = ocfs2_reflink_xattr_block(args, blk_bh, new_blk_bh);
|
|
|
|
else
|
|
|
|
ret = ocfs2_reflink_xattr_tree(args, blk_bh, new_blk_bh);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
brelse(new_blk_bh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:47:56 -06:00
|
|
|
static int ocfs2_reflink_xattr_no_security(struct ocfs2_xattr_entry *xe)
|
|
|
|
{
|
|
|
|
int type = ocfs2_xattr_get_type(xe);
|
|
|
|
|
|
|
|
return type != OCFS2_XATTR_INDEX_SECURITY &&
|
|
|
|
type != OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS &&
|
|
|
|
type != OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:43:55 -06:00
|
|
|
int ocfs2_reflink_xattrs(struct inode *old_inode,
|
|
|
|
struct buffer_head *old_bh,
|
|
|
|
struct inode *new_inode,
|
2009-08-17 21:47:56 -06:00
|
|
|
struct buffer_head *new_bh,
|
|
|
|
bool preserve_security)
|
2009-08-17 21:43:55 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ocfs2_xattr_reflink args;
|
|
|
|
struct ocfs2_inode_info *oi = OCFS2_I(old_inode);
|
|
|
|
struct ocfs2_dinode *di = (struct ocfs2_dinode *)old_bh->b_data;
|
|
|
|
struct buffer_head *blk_bh = NULL;
|
|
|
|
struct ocfs2_cached_dealloc_ctxt dealloc;
|
|
|
|
struct ocfs2_refcount_tree *ref_tree;
|
|
|
|
struct buffer_head *ref_root_bh = NULL;
|
|
|
|
|
|
|
|
ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb),
|
|
|
|
le64_to_cpu(di->i_refcount_loc),
|
|
|
|
1, &ref_tree, &ref_root_bh);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ocfs2_init_dealloc_ctxt(&dealloc);
|
|
|
|
|
|
|
|
args.old_inode = old_inode;
|
|
|
|
args.new_inode = new_inode;
|
|
|
|
args.old_bh = old_bh;
|
|
|
|
args.new_bh = new_bh;
|
|
|
|
args.ref_ci = &ref_tree->rf_ci;
|
|
|
|
args.ref_root_bh = ref_root_bh;
|
|
|
|
args.dealloc = &dealloc;
|
2009-08-17 21:47:56 -06:00
|
|
|
if (preserve_security)
|
|
|
|
args.xattr_reflinked = NULL;
|
|
|
|
else
|
|
|
|
args.xattr_reflinked = ocfs2_reflink_xattr_no_security;
|
2009-08-17 21:43:55 -06:00
|
|
|
|
|
|
|
if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
|
|
|
|
ret = ocfs2_reflink_xattr_inline(&args);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!di->i_xattr_loc)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
ret = ocfs2_read_xattr_block(old_inode, le64_to_cpu(di->i_xattr_loc),
|
|
|
|
&blk_bh);
|
|
|
|
if (ret < 0) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_reflink_xattr_in_block(&args, blk_bh);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
brelse(blk_bh);
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb),
|
|
|
|
ref_tree, 1);
|
|
|
|
brelse(ref_root_bh);
|
|
|
|
|
|
|
|
if (ocfs2_dealloc_has_cluster(&dealloc)) {
|
|
|
|
ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1);
|
|
|
|
ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:47:56 -06:00
|
|
|
/*
|
|
|
|
* Initialize security and acl for a already created inode.
|
|
|
|
* Used for reflink a non-preserve-security file.
|
|
|
|
*
|
|
|
|
* It uses common api like ocfs2_xattr_set, so the caller
|
|
|
|
* must not hold any lock expect i_mutex.
|
|
|
|
*/
|
|
|
|
int ocfs2_init_security_and_acl(struct inode *dir,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct buffer_head *dir_bh = NULL;
|
|
|
|
struct ocfs2_security_xattr_info si = {
|
|
|
|
.enable = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ocfs2_init_security_get(inode, dir, &si);
|
|
|
|
if (!ret) {
|
2009-11-13 02:52:56 -07:00
|
|
|
ret = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
|
|
|
|
si.name, si.value, si.value_len,
|
|
|
|
XATTR_CREATE);
|
2009-08-17 21:47:56 -06:00
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
} else if (ret != -EOPNOTSUPP) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_inode_lock(dir, &dir_bh, 0);
|
|
|
|
if (ret) {
|
|
|
|
mlog_errno(ret);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ocfs2_init_acl(NULL, inode, dir, NULL, dir_bh, NULL, NULL);
|
|
|
|
if (ret)
|
|
|
|
mlog_errno(ret);
|
|
|
|
|
|
|
|
ocfs2_inode_unlock(dir, 0);
|
|
|
|
brelse(dir_bh);
|
|
|
|
leave:
|
|
|
|
return ret;
|
|
|
|
}
|
2008-11-13 20:16:27 -07:00
|
|
|
/*
|
|
|
|
* 'security' attributes support
|
|
|
|
*/
|
2009-11-13 02:52:56 -07:00
|
|
|
static size_t ocfs2_xattr_security_list(struct dentry *dentry, char *list,
|
2008-11-13 20:16:27 -07:00
|
|
|
size_t list_size, const char *name,
|
2009-11-13 02:52:56 -07:00
|
|
|
size_t name_len, int type)
|
2008-11-13 20:16:27 -07:00
|
|
|
{
|
|
|
|
const size_t prefix_len = XATTR_SECURITY_PREFIX_LEN;
|
|
|
|
const size_t total_len = prefix_len + name_len + 1;
|
|
|
|
|
|
|
|
if (list && total_len <= list_size) {
|
|
|
|
memcpy(list, XATTR_SECURITY_PREFIX, prefix_len);
|
|
|
|
memcpy(list + prefix_len, name, name_len);
|
|
|
|
list[prefix_len + name_len] = '\0';
|
|
|
|
}
|
|
|
|
return total_len;
|
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_security_get(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
2008-11-13 20:16:27 -07:00
|
|
|
{
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
|
|
|
|
name, buffer, size);
|
2008-11-13 20:16:27 -07:00
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name,
|
|
|
|
const void *value, size_t size, int flags, int type)
|
2008-11-13 20:16:27 -07:00
|
|
|
{
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
|
|
|
|
name, value, size, flags);
|
2008-11-13 20:16:27 -07:00
|
|
|
}
|
|
|
|
|
2008-11-13 20:16:41 -07:00
|
|
|
int ocfs2_init_security_get(struct inode *inode,
|
|
|
|
struct inode *dir,
|
|
|
|
struct ocfs2_security_xattr_info *si)
|
|
|
|
{
|
2008-12-16 19:22:56 -07:00
|
|
|
/* check whether ocfs2 support feature xattr */
|
|
|
|
if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb)))
|
|
|
|
return -EOPNOTSUPP;
|
2008-11-13 20:16:41 -07:00
|
|
|
return security_inode_init_security(inode, dir, &si->name, &si->value,
|
|
|
|
&si->value_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
int 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)
|
|
|
|
{
|
|
|
|
return ocfs2_xattr_set_handle(handle, inode, di_bh,
|
|
|
|
OCFS2_XATTR_INDEX_SECURITY,
|
|
|
|
si->name, si->value, si->value_len, 0,
|
|
|
|
xattr_ac, data_ac);
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:16:27 -07:00
|
|
|
struct xattr_handler ocfs2_xattr_security_handler = {
|
|
|
|
.prefix = XATTR_SECURITY_PREFIX,
|
|
|
|
.list = ocfs2_xattr_security_list,
|
|
|
|
.get = ocfs2_xattr_security_get,
|
|
|
|
.set = ocfs2_xattr_security_set,
|
|
|
|
};
|
|
|
|
|
2008-10-07 15:52:59 -06:00
|
|
|
/*
|
|
|
|
* 'trusted' attributes support
|
|
|
|
*/
|
2009-11-13 02:52:56 -07:00
|
|
|
static size_t ocfs2_xattr_trusted_list(struct dentry *dentry, char *list,
|
2008-10-07 15:52:59 -06:00
|
|
|
size_t list_size, const char *name,
|
2009-11-13 02:52:56 -07:00
|
|
|
size_t name_len, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
2008-10-23 02:34:13 -06:00
|
|
|
const size_t prefix_len = XATTR_TRUSTED_PREFIX_LEN;
|
2008-10-07 15:52:59 -06:00
|
|
|
const size_t total_len = prefix_len + name_len + 1;
|
|
|
|
|
|
|
|
if (list && total_len <= list_size) {
|
|
|
|
memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len);
|
|
|
|
memcpy(list + prefix_len, name, name_len);
|
|
|
|
list[prefix_len + name_len] = '\0';
|
|
|
|
}
|
|
|
|
return total_len;
|
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_trusted_get(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
|
|
|
|
name, buffer, size);
|
2008-10-07 15:52:59 -06:00
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_trusted_set(struct dentry *dentry, const char *name,
|
|
|
|
const void *value, size_t size, int flags, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
|
|
|
|
name, value, size, flags);
|
2008-10-07 15:52:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
struct xattr_handler ocfs2_xattr_trusted_handler = {
|
|
|
|
.prefix = XATTR_TRUSTED_PREFIX,
|
|
|
|
.list = ocfs2_xattr_trusted_list,
|
|
|
|
.get = ocfs2_xattr_trusted_get,
|
|
|
|
.set = ocfs2_xattr_trusted_set,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'user' attributes support
|
|
|
|
*/
|
2009-11-13 02:52:56 -07:00
|
|
|
static size_t ocfs2_xattr_user_list(struct dentry *dentry, char *list,
|
2008-10-07 15:52:59 -06:00
|
|
|
size_t list_size, const char *name,
|
2009-11-13 02:52:56 -07:00
|
|
|
size_t name_len, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
2008-10-23 02:34:13 -06:00
|
|
|
const size_t prefix_len = XATTR_USER_PREFIX_LEN;
|
2008-10-07 15:52:59 -06:00
|
|
|
const size_t total_len = prefix_len + name_len + 1;
|
2009-11-13 02:52:56 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
|
2008-10-07 15:52:59 -06:00
|
|
|
|
|
|
|
if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (list && total_len <= list_size) {
|
|
|
|
memcpy(list, XATTR_USER_PREFIX, prefix_len);
|
|
|
|
memcpy(list + prefix_len, name, name_len);
|
|
|
|
list[prefix_len + name_len] = '\0';
|
|
|
|
}
|
|
|
|
return total_len;
|
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_user_get(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
2009-11-13 02:52:56 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
|
2008-10-07 15:52:59 -06:00
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
|
|
|
|
return -EOPNOTSUPP;
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name,
|
2008-10-07 15:52:59 -06:00
|
|
|
buffer, size);
|
|
|
|
}
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
static int ocfs2_xattr_user_set(struct dentry *dentry, const char *name,
|
|
|
|
const void *value, size_t size, int flags, int type)
|
2008-10-07 15:52:59 -06:00
|
|
|
{
|
2009-11-13 02:52:56 -07:00
|
|
|
struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
|
2008-10-07 15:52:59 -06:00
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2009-11-13 02:52:56 -07:00
|
|
|
return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER,
|
|
|
|
name, value, size, flags);
|
2008-10-07 15:52:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
struct xattr_handler ocfs2_xattr_user_handler = {
|
|
|
|
.prefix = XATTR_USER_PREFIX,
|
|
|
|
.list = ocfs2_xattr_user_list,
|
|
|
|
.get = ocfs2_xattr_user_get,
|
|
|
|
.set = ocfs2_xattr_user_set,
|
|
|
|
};
|