2007-11-16 23:45:54 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Red Hat. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/rwsem.h>
|
|
|
|
#include <linux/xattr.h>
|
2009-02-04 21:29:13 +07:00
|
|
|
#include <linux/security.h>
|
2013-12-20 20:16:43 +07:00
|
|
|
#include <linux/posix_acl_xattr.h>
|
2007-11-16 23:45:54 +07:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "btrfs_inode.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "xattr.h"
|
|
|
|
#include "disk-io.h"
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 18:47:46 +07:00
|
|
|
#include "props.h"
|
2014-11-09 15:38:39 +07:00
|
|
|
#include "locking.h"
|
2008-07-24 23:16:36 +07:00
|
|
|
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
ssize_t __btrfs_getxattr(struct inode *inode, const char *name,
|
|
|
|
void *buffer, size_t size)
|
2007-11-16 23:45:54 +07:00
|
|
|
{
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
int ret = 0;
|
|
|
|
unsigned long data_ptr;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2008-08-28 17:21:17 +07:00
|
|
|
if (!path)
|
2007-11-16 23:45:54 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* lookup the xattr by name */
|
2011-04-20 09:31:50 +07:00
|
|
|
di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode), name,
|
2007-11-16 23:45:54 +07:00
|
|
|
strlen(name), 0);
|
2009-01-21 22:49:16 +07:00
|
|
|
if (!di) {
|
2007-11-16 23:45:54 +07:00
|
|
|
ret = -ENODATA;
|
|
|
|
goto out;
|
2009-01-21 22:49:16 +07:00
|
|
|
} else if (IS_ERR(di)) {
|
|
|
|
ret = PTR_ERR(di);
|
|
|
|
goto out;
|
2007-11-16 23:45:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
/* if size is 0, that means we want the size of the attr */
|
|
|
|
if (!size) {
|
|
|
|
ret = btrfs_dir_data_len(leaf, di);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now get the data out of our dir_item */
|
|
|
|
if (btrfs_dir_data_len(leaf, di) > size) {
|
|
|
|
ret = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-01-21 22:49:16 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The way things are packed into the leaf is like this
|
|
|
|
* |struct btrfs_dir_item|name|data|
|
|
|
|
* where name is the xattr name, so security.foo, and data is the
|
|
|
|
* content of the xattr. data_ptr points to the location in memory
|
|
|
|
* where the data starts in the in memory leaf
|
|
|
|
*/
|
2007-11-16 23:45:54 +07:00
|
|
|
data_ptr = (unsigned long)((char *)(di + 1) +
|
|
|
|
btrfs_dir_name_len(leaf, di));
|
|
|
|
read_extent_buffer(leaf, buffer, data_ptr,
|
2007-11-19 22:18:19 +07:00
|
|
|
btrfs_dir_data_len(leaf, di));
|
2007-11-16 23:45:54 +07:00
|
|
|
ret = btrfs_dir_data_len(leaf, di);
|
|
|
|
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-12 16:35:27 +07:00
|
|
|
static int do_setxattr(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode, const char *name,
|
|
|
|
const void *value, size_t size, int flags)
|
2007-11-16 23:45:54 +07:00
|
|
|
{
|
2014-11-09 15:38:39 +07:00
|
|
|
struct btrfs_dir_item *di = NULL;
|
2007-11-16 23:45:54 +07:00
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
struct btrfs_path *path;
|
2009-11-12 16:35:27 +07:00
|
|
|
size_t name_len = strlen(name);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (name_len + size > BTRFS_MAX_XATTR_SIZE(root))
|
|
|
|
return -ENOSPC;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2008-08-28 17:21:17 +07:00
|
|
|
if (!path)
|
2007-11-16 23:45:54 +07:00
|
|
|
return -ENOMEM;
|
2014-11-09 15:38:39 +07:00
|
|
|
path->skip_release_on_error = 1;
|
|
|
|
|
|
|
|
if (!value) {
|
|
|
|
di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(inode),
|
|
|
|
name, name_len, -1);
|
|
|
|
if (!di && (flags & XATTR_REPLACE))
|
|
|
|
ret = -ENODATA;
|
|
|
|
else if (di)
|
|
|
|
ret = btrfs_delete_one_dir_name(trans, root, path, di);
|
|
|
|
goto out;
|
|
|
|
}
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
/*
|
|
|
|
* For a replace we can't just do the insert blindly.
|
|
|
|
* Do a lookup first (read-only btrfs_search_slot), and return if xattr
|
|
|
|
* doesn't exist. If it exists, fall down below to the insert/replace
|
|
|
|
* path - we can't race with a concurrent xattr delete, because the VFS
|
|
|
|
* locks the inode's i_mutex before calling setxattr or removexattr.
|
|
|
|
*/
|
2011-05-27 23:06:11 +07:00
|
|
|
if (flags & XATTR_REPLACE) {
|
2014-11-09 15:38:39 +07:00
|
|
|
ASSERT(mutex_is_locked(&inode->i_mutex));
|
|
|
|
di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode),
|
|
|
|
name, name_len, 0);
|
|
|
|
if (!di) {
|
2011-05-27 23:06:11 +07:00
|
|
|
ret = -ENODATA;
|
2007-11-16 23:45:54 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2011-04-21 06:20:15 +07:00
|
|
|
btrfs_release_path(path);
|
2014-11-09 15:38:39 +07:00
|
|
|
di = NULL;
|
|
|
|
}
|
2011-09-11 21:52:25 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(inode),
|
|
|
|
name, name_len, value, size);
|
|
|
|
if (ret == -EOVERFLOW) {
|
2011-09-11 21:52:25 +07:00
|
|
|
/*
|
2014-11-09 15:38:39 +07:00
|
|
|
* We have an existing item in a leaf, split_leaf couldn't
|
|
|
|
* expand it. That item might have or not a dir_item that
|
|
|
|
* matches our target xattr, so lets check.
|
2011-09-11 21:52:25 +07:00
|
|
|
*/
|
2014-11-09 15:38:39 +07:00
|
|
|
ret = 0;
|
|
|
|
btrfs_assert_tree_locked(path->nodes[0]);
|
|
|
|
di = btrfs_match_dir_item_name(root, path, name, name_len);
|
|
|
|
if (!di && !(flags & XATTR_REPLACE)) {
|
|
|
|
ret = -ENOSPC;
|
2012-11-28 17:43:12 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2014-11-09 15:38:39 +07:00
|
|
|
} else if (ret == -EEXIST) {
|
|
|
|
ret = 0;
|
|
|
|
di = btrfs_match_dir_item_name(root, path, name, name_len);
|
|
|
|
ASSERT(di); /* logic error */
|
|
|
|
} else if (ret) {
|
|
|
|
goto out;
|
2011-05-27 23:06:11 +07:00
|
|
|
}
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
if (di && (flags & XATTR_CREATE)) {
|
2011-10-14 00:09:22 +07:00
|
|
|
ret = -EEXIST;
|
2014-11-09 15:38:39 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2011-10-14 00:09:22 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
if (di) {
|
2011-05-27 23:06:11 +07:00
|
|
|
/*
|
2014-11-09 15:38:39 +07:00
|
|
|
* We're doing a replace, and it must be atomic, that is, at
|
|
|
|
* any point in time we have either the old or the new xattr
|
|
|
|
* value in the tree. We don't want readers (getxattr and
|
|
|
|
* listxattrs) to miss a value, this is specially important
|
|
|
|
* for ACLs.
|
2011-05-27 23:06:11 +07:00
|
|
|
*/
|
2014-11-09 15:38:39 +07:00
|
|
|
const int slot = path->slots[0];
|
|
|
|
struct extent_buffer *leaf = path->nodes[0];
|
|
|
|
const u16 old_data_len = btrfs_dir_data_len(leaf, di);
|
|
|
|
const u32 item_size = btrfs_item_size_nr(leaf, slot);
|
|
|
|
const u32 data_size = sizeof(*di) + name_len + size;
|
|
|
|
struct btrfs_item *item;
|
|
|
|
unsigned long data_ptr;
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
if (size > old_data_len) {
|
|
|
|
if (btrfs_leaf_free_space(root, leaf) <
|
|
|
|
(size - old_data_len)) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-05-27 23:06:11 +07:00
|
|
|
}
|
2008-07-24 23:16:36 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
if (old_data_len + name_len + sizeof(*di) == item_size) {
|
|
|
|
/* No other xattrs packed in the same leaf item. */
|
|
|
|
if (size > old_data_len)
|
|
|
|
btrfs_extend_item(root, path,
|
|
|
|
size - old_data_len);
|
|
|
|
else if (size < old_data_len)
|
|
|
|
btrfs_truncate_item(root, path, data_size, 1);
|
|
|
|
} else {
|
|
|
|
/* There are other xattrs packed in the same item. */
|
|
|
|
ret = btrfs_delete_one_dir_name(trans, root, path, di);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
btrfs_extend_item(root, path, data_size);
|
|
|
|
}
|
2011-05-27 23:06:11 +07:00
|
|
|
|
2014-11-09 15:38:39 +07:00
|
|
|
item = btrfs_item_nr(slot);
|
|
|
|
ptr = btrfs_item_ptr(leaf, slot, char);
|
|
|
|
ptr += btrfs_item_size(leaf, item) - data_size;
|
|
|
|
di = (struct btrfs_dir_item *)ptr;
|
|
|
|
btrfs_set_dir_data_len(leaf, di, size);
|
|
|
|
data_ptr = ((unsigned long)(di + 1)) + name_len;
|
|
|
|
write_extent_buffer(leaf, value, data_ptr, size);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
} else {
|
2011-05-27 23:06:11 +07:00
|
|
|
/*
|
2014-11-09 15:38:39 +07:00
|
|
|
* Insert, and we had space for the xattr, so path->slots[0] is
|
|
|
|
* where our xattr dir_item is and btrfs_insert_xattr_item()
|
|
|
|
* filled it.
|
2011-05-27 23:06:11 +07:00
|
|
|
*/
|
2007-11-16 23:45:54 +07:00
|
|
|
}
|
2009-11-12 16:35:27 +07:00
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-09-11 21:52:25 +07:00
|
|
|
/*
|
|
|
|
* @value: "" makes the attribute to empty, NULL removes it
|
|
|
|
*/
|
2009-11-12 16:35:27 +07:00
|
|
|
int __btrfs_setxattr(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode, const char *name,
|
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (trans)
|
|
|
|
return do_setxattr(trans, inode, name, value, size, flags);
|
|
|
|
|
2010-05-16 21:48:46 +07:00
|
|
|
trans = btrfs_start_transaction(root, 2);
|
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2009-11-12 16:35:27 +07:00
|
|
|
ret = do_setxattr(trans, inode, name, value, size, flags);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2012-04-06 02:03:02 +07:00
|
|
|
inode_inc_iversion(inode);
|
2009-11-12 16:35:27 +07:00
|
|
|
inode->i_ctime = CURRENT_TIME;
|
2012-10-12 02:53:56 +07:00
|
|
|
set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
|
2009-11-12 16:35:27 +07:00
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
|
|
|
BUG_ON(ret);
|
|
|
|
out:
|
2012-01-13 07:10:12 +07:00
|
|
|
btrfs_end_transaction(trans, root);
|
2007-11-16 23:45:54 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
|
|
|
|
{
|
|
|
|
struct btrfs_key key, found_key;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_dir_item *di;
|
2011-03-17 14:17:59 +07:00
|
|
|
int ret = 0, slot;
|
2008-08-28 17:21:16 +07:00
|
|
|
size_t total_size = 0, size_left = size;
|
2007-11-16 23:45:54 +07:00
|
|
|
unsigned long name_ptr;
|
2008-08-28 17:21:16 +07:00
|
|
|
size_t name_len;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ok we want all objects associated with this id.
|
|
|
|
* NOTE: we set key.offset = 0; because we want to start with the
|
|
|
|
* first xattr that we find and walk forward
|
|
|
|
*/
|
2011-04-20 09:31:50 +07:00
|
|
|
key.objectid = btrfs_ino(inode);
|
2014-06-04 23:41:45 +07:00
|
|
|
key.type = BTRFS_XATTR_ITEM_KEY;
|
2007-11-16 23:45:54 +07:00
|
|
|
key.offset = 0;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2007-11-19 22:18:17 +07:00
|
|
|
path->reada = 2;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
|
|
|
/* search for our xattrs */
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
2011-03-17 14:17:59 +07:00
|
|
|
|
2007-11-16 23:45:54 +07:00
|
|
|
while (1) {
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
|
|
|
|
/* this is where we start walking through the path */
|
2011-03-17 14:17:59 +07:00
|
|
|
if (slot >= btrfs_header_nritems(leaf)) {
|
2007-11-16 23:45:54 +07:00
|
|
|
/*
|
|
|
|
* if we've reached the last slot in this leaf we need
|
|
|
|
* to go to the next leaf and reset everything
|
|
|
|
*/
|
2011-03-17 14:17:59 +07:00
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
|
|
|
else if (ret > 0)
|
|
|
|
break;
|
|
|
|
continue;
|
2007-11-16 23:45:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
|
|
|
|
|
|
|
/* check to make sure this item is what we want */
|
|
|
|
if (found_key.objectid != key.objectid)
|
|
|
|
break;
|
2014-06-04 23:41:45 +07:00
|
|
|
if (found_key.type != BTRFS_XATTR_ITEM_KEY)
|
2007-11-16 23:45:54 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
|
2011-03-17 03:47:17 +07:00
|
|
|
if (verify_dir_item(root, leaf, di))
|
2012-11-26 09:58:36 +07:00
|
|
|
goto next;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:16 +07:00
|
|
|
name_len = btrfs_dir_name_len(leaf, di);
|
|
|
|
total_size += name_len + 1;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
|
|
|
/* we are just looking for how big our buffer needs to be */
|
|
|
|
if (!size)
|
2011-03-17 14:17:59 +07:00
|
|
|
goto next;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:16 +07:00
|
|
|
if (!buffer || (name_len + 1) > size_left) {
|
2007-11-16 23:45:54 +07:00
|
|
|
ret = -ERANGE;
|
2008-12-17 22:21:26 +07:00
|
|
|
goto err;
|
2007-11-16 23:45:54 +07:00
|
|
|
}
|
|
|
|
|
2008-08-28 17:21:16 +07:00
|
|
|
name_ptr = (unsigned long)(di + 1);
|
|
|
|
read_extent_buffer(leaf, buffer, name_ptr, name_len);
|
|
|
|
buffer[name_len] = '\0';
|
|
|
|
|
|
|
|
size_left -= name_len + 1;
|
|
|
|
buffer += name_len + 1;
|
2011-03-17 14:17:59 +07:00
|
|
|
next:
|
|
|
|
path->slots[0]++;
|
2007-11-16 23:45:54 +07:00
|
|
|
}
|
|
|
|
ret = total_size;
|
|
|
|
|
|
|
|
err:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-08-28 17:21:17 +07:00
|
|
|
* List of handlers for synthetic system.* attributes. All real ondisk
|
|
|
|
* attributes are handled directly.
|
|
|
|
*/
|
2010-05-14 07:53:15 +07:00
|
|
|
const struct xattr_handler *btrfs_xattr_handlers[] = {
|
2009-10-14 00:50:18 +07:00
|
|
|
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
|
2013-12-20 20:16:43 +07:00
|
|
|
&posix_acl_access_xattr_handler,
|
|
|
|
&posix_acl_default_xattr_handler,
|
2008-08-28 17:21:17 +07:00
|
|
|
#endif
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the attribute is in a supported namespace.
|
|
|
|
*
|
|
|
|
* This applied after the check for the synthetic attributes in the system
|
|
|
|
* namespace.
|
2007-11-16 23:45:54 +07:00
|
|
|
*/
|
2008-08-28 17:21:17 +07:00
|
|
|
static bool btrfs_is_valid_xattr(const char *name)
|
|
|
|
{
|
2009-01-06 09:25:51 +07:00
|
|
|
return !strncmp(name, XATTR_SECURITY_PREFIX,
|
|
|
|
XATTR_SECURITY_PREFIX_LEN) ||
|
2008-08-28 17:21:17 +07:00
|
|
|
!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) ||
|
|
|
|
!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) ||
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 18:47:46 +07:00
|
|
|
!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) ||
|
|
|
|
!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN);
|
2008-01-15 02:33:35 +07:00
|
|
|
}
|
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
ssize_t btrfs_getxattr(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If this is a request for a synthetic attribute in the system.*
|
|
|
|
* namespace use the generic infrastructure to resolve a handler
|
|
|
|
* for it via sb->s_xattr.
|
|
|
|
*/
|
|
|
|
if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
|
|
|
|
return generic_getxattr(dentry, name, buffer, size);
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
if (!btrfs_is_valid_xattr(name))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return __btrfs_getxattr(dentry->d_inode, name, buffer, size);
|
|
|
|
}
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
|
|
|
|
size_t size, int flags)
|
|
|
|
{
|
2010-12-20 15:04:08 +07:00
|
|
|
struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The permission on security.* and system.* is not checked
|
|
|
|
* in permission().
|
|
|
|
*/
|
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
return -EROFS;
|
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
/*
|
|
|
|
* If this is a request for a synthetic attribute in the system.*
|
|
|
|
* namespace use the generic infrastructure to resolve a handler
|
|
|
|
* for it via sb->s_xattr.
|
|
|
|
*/
|
|
|
|
if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
|
|
|
|
return generic_setxattr(dentry, name, value, size, flags);
|
2007-11-16 23:45:54 +07:00
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
if (!btrfs_is_valid_xattr(name))
|
|
|
|
return -EOPNOTSUPP;
|
2007-11-16 23:45:54 +07:00
|
|
|
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 18:47:46 +07:00
|
|
|
if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
|
|
|
|
return btrfs_set_prop(dentry->d_inode, name,
|
|
|
|
value, size, flags);
|
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
if (size == 0)
|
|
|
|
value = ""; /* empty EA, do not remove */
|
2009-11-12 16:35:27 +07:00
|
|
|
|
|
|
|
return __btrfs_setxattr(NULL, dentry->d_inode, name, value, size,
|
|
|
|
flags);
|
2008-08-28 17:21:17 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_removexattr(struct dentry *dentry, const char *name)
|
|
|
|
{
|
2010-12-20 15:04:08 +07:00
|
|
|
struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The permission on security.* and system.* is not checked
|
|
|
|
* in permission().
|
|
|
|
*/
|
|
|
|
if (btrfs_root_readonly(root))
|
|
|
|
return -EROFS;
|
|
|
|
|
2008-08-28 17:21:17 +07:00
|
|
|
/*
|
|
|
|
* If this is a request for a synthetic attribute in the system.*
|
|
|
|
* namespace use the generic infrastructure to resolve a handler
|
|
|
|
* for it via sb->s_xattr.
|
|
|
|
*/
|
|
|
|
if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
|
|
|
|
return generic_removexattr(dentry, name);
|
|
|
|
|
|
|
|
if (!btrfs_is_valid_xattr(name))
|
|
|
|
return -EOPNOTSUPP;
|
2009-11-12 16:35:27 +07:00
|
|
|
|
Btrfs: add support for inode properties
This change adds infrastructure to allow for generic properties for
inodes. Properties are name/value pairs that can be associated with
inodes for different purposes. They are stored as xattrs with the
prefix "btrfs."
Properties can be inherited - this means when a directory inode has
inheritable properties set, these are added to new inodes created
under that directory. Further, subvolumes can also have properties
associated with them, and they can be inherited from their parent
subvolume. Naturally, directory properties have priority over subvolume
properties (in practice a subvolume property is just a regular
property associated with the root inode, objectid 256, of the
subvolume's fs tree).
This change also adds one specific property implementation, named
"compression", whose values can be "lzo" or "zlib" and it's an
inheritable property.
The corresponding changes to btrfs-progs were also implemented.
A patch with xfstests for this feature will follow once there's
agreement on this change/feature.
Further, the script at the bottom of this commit message was used to
do some benchmarks to measure any performance penalties of this feature.
Basically the tests correspond to:
Test 1 - create a filesystem and mount it with compress-force=lzo,
then sequentially create N files of 64Kb each, measure how long it took
to create the files, unmount the filesystem, mount the filesystem and
perform an 'ls -lha' against the test directory holding the N files, and
report the time the command took.
Test 2 - create a filesystem and don't use any compression option when
mounting it - instead set the compression property of the subvolume's
root to 'lzo'. Then create N files of 64Kb, and report the time it took.
The unmount the filesystem, mount it again and perform an 'ls -lha' like
in the former test. This means every single file ends up with a property
(xattr) associated to it.
Test 3 - same as test 2, but uses 4 properties - 3 are duplicates of the
compression property, have no real effect other than adding more work
when inheriting properties and taking more btree leaf space.
Test 4 - same as test 3 but with 10 properties per file.
Results (in seconds, and averages of 5 runs each), for different N
numbers of files follow.
* Without properties (test 1)
file creation time ls -lha time
10 000 files 3.49 0.76
100 000 files 47.19 8.37
1 000 000 files 518.51 107.06
* With 1 property (compression property set to lzo - test 2)
file creation time ls -lha time
10 000 files 3.63 0.93
100 000 files 48.56 9.74
1 000 000 files 537.72 125.11
* With 4 properties (test 3)
file creation time ls -lha time
10 000 files 3.94 1.20
100 000 files 52.14 11.48
1 000 000 files 572.70 142.13
* With 10 properties (test 4)
file creation time ls -lha time
10 000 files 4.61 1.35
100 000 files 58.86 13.83
1 000 000 files 656.01 177.61
The increased latencies with properties are essencialy because of:
*) When creating an inode, we now synchronously write 1 more item
(an xattr item) for each property inherited from the parent dir
(or subvolume). This could be done in an asynchronous way such
as we do for dir intex items (delayed-inode.c), which could help
reduce the file creation latency;
*) With properties, we now have larger fs trees. For this particular
test each xattr item uses 75 bytes of leaf space in the fs tree.
This could be less by using a new item for xattr items, instead of
the current btrfs_dir_item, since we could cut the 'location' and
'type' fields (saving 18 bytes) and maybe 'transid' too (saving a
total of 26 bytes per xattr item) from the btrfs_dir_item type.
Also tried batching the xattr insertions (ignoring proper hash
collision handling, since it didn't exist) when creating files that
inherit properties from their parent inode/subvolume, but the end
results were (surprisingly) essentially the same.
Test script:
$ cat test.pl
#!/usr/bin/perl -w
use strict;
use Time::HiRes qw(time);
use constant NUM_FILES => 10_000;
use constant FILE_SIZES => (64 * 1024);
use constant DEV => '/dev/sdb4';
use constant MNT_POINT => '/home/fdmanana/btrfs-tests/dev';
use constant TEST_DIR => (MNT_POINT . '/testdir');
system("mkfs.btrfs", "-l", "16384", "-f", DEV) == 0 or die "mkfs.btrfs failed!";
# following line for testing without properties
#system("mount", "-o", "compress-force=lzo", DEV, MNT_POINT) == 0 or die "mount failed!";
# following 2 lines for testing with properties
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
system("btrfs", "prop", "set", MNT_POINT, "compression", "lzo") == 0 or die "set prop failed!";
system("mkdir", TEST_DIR) == 0 or die "mkdir failed!";
my ($t1, $t2);
$t1 = time();
for (my $i = 1; $i <= NUM_FILES; $i++) {
my $p = TEST_DIR . '/file_' . $i;
open(my $f, '>', $p) or die "Error opening file!";
$f->autoflush(1);
for (my $j = 0; $j < FILE_SIZES; $j += 4096) {
print $f ('A' x 4096) or die "Error writing to file!";
}
close($f);
}
$t2 = time();
print "Time to create " . NUM_FILES . ": " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
system("mount", DEV, MNT_POINT) == 0 or die "mount failed!";
$t1 = time();
system("bash -c 'ls -lha " . TEST_DIR . " > /dev/null'") == 0 or die "ls failed!";
$t2 = time();
print "Time to ls -lha all files: " . ($t2 - $t1) . " seconds.\n";
system("umount", DEV) == 0 or die "umount failed!";
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-01-07 18:47:46 +07:00
|
|
|
if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
|
|
|
|
return btrfs_set_prop(dentry->d_inode, name,
|
|
|
|
NULL, 0, XATTR_REPLACE);
|
|
|
|
|
2009-11-12 16:35:27 +07:00
|
|
|
return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0,
|
|
|
|
XATTR_REPLACE);
|
2008-08-28 17:21:17 +07:00
|
|
|
}
|
2009-02-04 21:29:13 +07:00
|
|
|
|
2013-04-26 03:41:01 +07:00
|
|
|
static int btrfs_initxattrs(struct inode *inode,
|
|
|
|
const struct xattr *xattr_array, void *fs_info)
|
2009-02-04 21:29:13 +07:00
|
|
|
{
|
2011-06-07 02:29:25 +07:00
|
|
|
const struct xattr *xattr;
|
|
|
|
struct btrfs_trans_handle *trans = fs_info;
|
2009-02-04 21:29:13 +07:00
|
|
|
char *name;
|
2011-06-07 02:29:25 +07:00
|
|
|
int err = 0;
|
2009-02-04 21:29:13 +07:00
|
|
|
|
2011-06-07 02:29:25 +07:00
|
|
|
for (xattr = xattr_array; xattr->name != NULL; xattr++) {
|
|
|
|
name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
|
|
|
|
strlen(xattr->name) + 1, GFP_NOFS);
|
|
|
|
if (!name) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2009-02-04 21:29:13 +07:00
|
|
|
strcpy(name, XATTR_SECURITY_PREFIX);
|
2011-06-07 02:29:25 +07:00
|
|
|
strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
|
|
|
|
err = __btrfs_setxattr(trans, inode, name,
|
|
|
|
xattr->value, xattr->value_len, 0);
|
2009-02-04 21:29:13 +07:00
|
|
|
kfree(name);
|
2011-06-07 02:29:25 +07:00
|
|
|
if (err < 0)
|
|
|
|
break;
|
2009-02-04 21:29:13 +07:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
2011-06-07 02:29:25 +07:00
|
|
|
|
|
|
|
int btrfs_xattr_security_init(struct btrfs_trans_handle *trans,
|
|
|
|
struct inode *inode, struct inode *dir,
|
|
|
|
const struct qstr *qstr)
|
|
|
|
{
|
|
|
|
return security_inode_init_security(inode, dir, qstr,
|
|
|
|
&btrfs_initxattrs, trans);
|
|
|
|
}
|