10 files changed, 545 insertions, 10 deletions

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index 1a44e42d602a..af7f000e905c 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -9,7 +9,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
            export.o tree-log.o free-space-cache.o zlib.o lzo.o \
            compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \
            reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \
-           uuid-tree.o
+           uuid-tree.o props.o
 
 btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
 btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 661b0ac90e8f..8fed2125689e 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -43,6 +43,7 @@
 #define BTRFS_INODE_COPY_EVERYTHING             8
 #define BTRFS_INODE_IN_DELALLOC_LIST            9
 #define BTRFS_INODE_READDIO_NEED_LOCK           10
+#define BTRFS_INODE_HAS_PROPS                   11
 
 /* in memory btrfs inode */
 struct btrfs_inode {
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index f52a60b9eba5..3cebb4aeddc7 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3703,7 +3703,9 @@ int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput);
 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
                               struct extent_state **cached_state);
 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
-                             struct btrfs_root *new_root, u64 new_dirid);
+                             struct btrfs_root *new_root,
+                             struct btrfs_root *parent_root,
+                             u64 new_dirid);
 int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
                          size_t size, struct bio *bio,
                          unsigned long bio_flags);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 23f18eb5fb55..1ea19cea96d0 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -58,6 +58,7 @@
 #include "inode-map.h"
 #include "backref.h"
 #include "hash.h"
+#include "props.h"
 
 struct btrfs_iget_args {
         u64 ino;
@@ -3265,7 +3266,8 @@ out:
  * slot is the slot the inode is in, objectid is the objectid of the inode
  */
 static noinline int acls_after_inode_item(struct extent_buffer *leaf,
-                                          int slot, u64 objectid)
+                                          int slot, u64 objectid,
+                                          int *first_xattr_slot)
 {
         u32 nritems = btrfs_header_nritems(leaf);
         struct btrfs_key found_key;
@@ -3281,6 +3283,7 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
         }
 
         slot++;
+        *first_xattr_slot = -1;
         while (slot < nritems) {
                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
 
@@ -3290,6 +3293,8 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
 
                 /* we found an xattr, assume we've got an acl */
                 if (found_key.type == BTRFS_XATTR_ITEM_KEY) {
+                        if (*first_xattr_slot == -1)
+                                *first_xattr_slot = slot;
                         if (found_key.offset == xattr_access ||
                             found_key.offset == xattr_default)
                                 return 1;
@@ -3318,6 +3323,8 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
          * something larger than an xattr.  We have to assume the inode
          * has acls
          */
+        if (*first_xattr_slot == -1)
+                *first_xattr_slot = slot;
         return 1;
 }
 
@@ -3337,6 +3344,7 @@ static void btrfs_read_locked_inode(struct inode *inode)
         u32 rdev;
         int ret;
         bool filled = false;
+        int first_xattr_slot;
 
         ret = btrfs_fill_inode(inode, &rdev);
         if (!ret)
@@ -3346,7 +3354,6 @@ static void btrfs_read_locked_inode(struct inode *inode)
         if (!path)
                 goto make_bad;
 
-        path->leave_spinning = 1;
         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
 
         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
@@ -3429,12 +3436,21 @@ cache_acl:
          * any xattrs or acls
          */
         maybe_acls = acls_after_inode_item(leaf, path->slots[0],
-                                           btrfs_ino(inode));
+                                           btrfs_ino(inode), &first_xattr_slot);
+        if (first_xattr_slot != -1) {
+                path->slots[0] = first_xattr_slot;
+                ret = btrfs_load_inode_props(inode, path);
+                if (ret)
+                        btrfs_err(root->fs_info,
+                                  "error loading props for ino %llu (root %llu): %d\n",
+                                  btrfs_ino(inode),
+                                  root->root_key.objectid, ret);
+        }
+        btrfs_free_path(path);
+
         if (!maybe_acls)
                 cache_no_acl(inode);
 
-        btrfs_free_path(path);
-
         switch (inode->i_mode & S_IFMT) {
         case S_IFREG:
                 inode->i_mapping->a_ops = &btrfs_aops;
@@ -5607,6 +5623,12 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
 
         btrfs_update_root_times(trans, root);
 
+        ret = btrfs_inode_inherit_props(trans, inode, dir);
+        if (ret)
+                btrfs_err(root->fs_info,
+                          "error inheriting props for ino %llu (root %llu): %d",
+                          btrfs_ino(inode), root->root_key.objectid, ret);
+
         return inode;
 fail:
         if (dir)
@@ -7889,7 +7911,9 @@ out:
  * create a new subvolume directory/inode (helper for the ioctl).
  */
 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
-                             struct btrfs_root *new_root, u64 new_dirid)
+                             struct btrfs_root *new_root,
+                             struct btrfs_root *parent_root,
+                             u64 new_dirid)
 {
         struct inode *inode;
         int err;
@@ -7907,6 +7931,12 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
         set_nlink(inode, 1);
         btrfs_i_size_write(inode, 0);
 
+        err = btrfs_subvol_inherit_props(trans, new_root, parent_root);
+        if (err)
+                btrfs_err(new_root->fs_info,
+                          "error inheriting subvolume %llu properties: %d\n",
+                          new_root->root_key.objectid, err);
+
         err = btrfs_update_inode(trans, new_root, inode);
 
         iput(inode);
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index ed3edc283255..3970f32b2b80 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -56,6 +56,7 @@
 #include "rcu-string.h"
 #include "send.h"
 #include "dev-replace.h"
+#include "props.h"
 #include "sysfs.h"
 
 static int btrfs_clone(struct inode *src, struct inode *inode,
@@ -281,9 +282,25 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         if (flags & FS_NOCOMP_FL) {
                 ip->flags &= ~BTRFS_INODE_COMPRESS;
                 ip->flags |= BTRFS_INODE_NOCOMPRESS;
+
+                ret = btrfs_set_prop(inode, "btrfs.compression", NULL, 0, 0);
+                if (ret && ret != -ENODATA)
+                        goto out_drop;
         } else if (flags & FS_COMPR_FL) {
+                const char *comp;
+
                 ip->flags |= BTRFS_INODE_COMPRESS;
                 ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
+
+                if (root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
+                        comp = "lzo";
+                else
+                        comp = "zlib";
+                ret = btrfs_set_prop(inode, "btrfs.compression",
+                                     comp, strlen(comp), 0);
+                if (ret)
+                        goto out_drop;
+
         } else {
                 ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
         }
@@ -502,7 +519,7 @@ static noinline int create_subvol(struct inode *dir,
 
         btrfs_record_root_in_trans(trans, new_root);
 
-        ret = btrfs_create_subvol_root(trans, new_root, new_dirid);
+        ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
         if (ret) {
                 /* We potentially lose an unused inode item here */
                 btrfs_abort_transaction(trans, root, ret);
diff --git a/fs/btrfs/props.c b/fs/btrfs/props.c
new file mode 100644
index 000000000000..129b1dd28527
--- /dev/null
+++ b/fs/btrfs/props.c
@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 2014 Filipe David Borba Manana <fdmanana@gmail.com>
+ *
+ * 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/hashtable.h>
+#include "props.h"
+#include "btrfs_inode.h"
+#include "hash.h"
+#include "transaction.h"
+#include "xattr.h"
+
+#define BTRFS_PROP_HANDLERS_HT_BITS 8
+static DEFINE_HASHTABLE(prop_handlers_ht, BTRFS_PROP_HANDLERS_HT_BITS);
+
+struct prop_handler {
+        struct hlist_node node;
+        const char *xattr_name;
+        int (*validate)(const char *value, size_t len);
+        int (*apply)(struct inode *inode, const char *value, size_t len);
+        const char *(*extract)(struct inode *inode);
+        int inheritable;
+};
+
+static int prop_compression_validate(const char *value, size_t len);
+static int prop_compression_apply(struct inode *inode,
+                                  const char *value,
+                                  size_t len);
+static const char *prop_compression_extract(struct inode *inode);
+
+static struct prop_handler prop_handlers[] = {
+        {
+                .xattr_name = XATTR_BTRFS_PREFIX "compression",
+                .validate = prop_compression_validate,
+                .apply = prop_compression_apply,
+                .extract = prop_compression_extract,
+                .inheritable = 1
+        },
+        {
+                .xattr_name = NULL
+        }
+};
+
+void __init btrfs_props_init(void)
+{
+        struct prop_handler *p;
+
+        hash_init(prop_handlers_ht);
+
+        for (p = &prop_handlers[0]; p->xattr_name; p++) {
+                u64 h = btrfs_name_hash(p->xattr_name, strlen(p->xattr_name));
+
+                hash_add(prop_handlers_ht, &p->node, h);
+        }
+}
+
+static const struct hlist_head *find_prop_handlers_by_hash(const u64 hash)
+{
+        struct hlist_head *h;
+
+        h = &prop_handlers_ht[hash_min(hash, BTRFS_PROP_HANDLERS_HT_BITS)];
+        if (hlist_empty(h))
+                return NULL;
+
+        return h;
+}
+
+static const struct prop_handler *
+find_prop_handler(const char *name,
+                  const struct hlist_head *handlers)
+{
+        struct prop_handler *h;
+
+        if (!handlers) {
+                u64 hash = btrfs_name_hash(name, strlen(name));
+
+                handlers = find_prop_handlers_by_hash(hash);
+                if (!handlers)
+                        return NULL;
+        }
+
+        hlist_for_each_entry(h, handlers, node)
+                if (!strcmp(h->xattr_name, name))
+                        return h;
+
+        return NULL;
+}
+
+static int __btrfs_set_prop(struct btrfs_trans_handle *trans,
+                            struct inode *inode,
+                            const char *name,
+                            const char *value,
+                            size_t value_len,
+                            int flags)
+{
+        const struct prop_handler *handler;
+        int ret;
+
+        if (strlen(name) <= XATTR_BTRFS_PREFIX_LEN)
+                return -EINVAL;
+
+        handler = find_prop_handler(name, NULL);
+        if (!handler)
+                return -EINVAL;
+
+        if (value_len == 0) {
+                ret = __btrfs_setxattr(trans, inode, handler->xattr_name,
+                                       NULL, 0, flags);
+                if (ret)
+                        return ret;
+
+                ret = handler->apply(inode, NULL, 0);
+                ASSERT(ret == 0);
+
+                return ret;
+        }
+
+        ret = handler->validate(value, value_len);
+        if (ret)
+                return ret;
+        ret = __btrfs_setxattr(trans, inode, handler->xattr_name,
+                               value, value_len, flags);
+        if (ret)
+                return ret;
+        ret = handler->apply(inode, value, value_len);
+        if (ret) {
+                __btrfs_setxattr(trans, inode, handler->xattr_name,
+                                 NULL, 0, flags);
+                return ret;
+        }
+
+        set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
+
+        return 0;
+}
+
+int btrfs_set_prop(struct inode *inode,
+                   const char *name,
+                   const char *value,
+                   size_t value_len,
+                   int flags)
+{
+        return __btrfs_set_prop(NULL, inode, name, value, value_len, flags);
+}
+
+static int iterate_object_props(struct btrfs_root *root,
+                                struct btrfs_path *path,
+                                u64 objectid,
+                                void (*iterator)(void *,
+                                                 const struct prop_handler *,
+                                                 const char *,
+                                                 size_t),
+                                void *ctx)
+{
+        int ret;
+        char *name_buf = NULL;
+        char *value_buf = NULL;
+        int name_buf_len = 0;
+        int value_buf_len = 0;
+
+        while (1) {
+                struct btrfs_key key;
+                struct btrfs_dir_item *di;
+                struct extent_buffer *leaf;
+                u32 total_len, cur, this_len;
+                int slot;
+                const struct hlist_head *handlers;
+
+                slot = path->slots[0];
+                leaf = path->nodes[0];
+
+                if (slot >= btrfs_header_nritems(leaf)) {
+                        ret = btrfs_next_leaf(root, path);
+                        if (ret < 0)
+                                goto out;
+                        else if (ret > 0)
+                                break;
+                        continue;
+                }
+
+                btrfs_item_key_to_cpu(leaf, &key, slot);
+                if (key.objectid != objectid)
+                        break;
+                if (key.type != BTRFS_XATTR_ITEM_KEY)
+                        break;
+
+                handlers = find_prop_handlers_by_hash(key.offset);
+                if (!handlers)
+                        goto next_slot;
+
+                di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
+                cur = 0;
+                total_len = btrfs_item_size_nr(leaf, slot);
+
+                while (cur < total_len) {
+                        u32 name_len = btrfs_dir_name_len(leaf, di);
+                        u32 data_len = btrfs_dir_data_len(leaf, di);
+                        unsigned long name_ptr, data_ptr;
+                        const struct prop_handler *handler;
+
+                        this_len = sizeof(*di) + name_len + data_len;
+                        name_ptr = (unsigned long)(di + 1);
+                        data_ptr = name_ptr + name_len;
+
+                        if (name_len <= XATTR_BTRFS_PREFIX_LEN ||
+                            memcmp_extent_buffer(leaf, XATTR_BTRFS_PREFIX,
+                                                 name_ptr,
+                                                 XATTR_BTRFS_PREFIX_LEN))
+                                goto next_dir_item;
+
+                        if (name_len >= name_buf_len) {
+                                kfree(name_buf);
+                                name_buf_len = name_len + 1;
+                                name_buf = kmalloc(name_buf_len, GFP_NOFS);
+                                if (!name_buf) {
+                                        ret = -ENOMEM;
+                                        goto out;
+                                }
+                        }
+                        read_extent_buffer(leaf, name_buf, name_ptr, name_len);
+                        name_buf[name_len] = '\0';
+
+                        handler = find_prop_handler(name_buf, handlers);
+                        if (!handler)
+                                goto next_dir_item;
+
+                        if (data_len > value_buf_len) {
+                                kfree(value_buf);
+                                value_buf_len = data_len;
+                                value_buf = kmalloc(data_len, GFP_NOFS);
+                                if (!value_buf) {
+                                        ret = -ENOMEM;
+                                        goto out;
+                                }
+                        }
+                        read_extent_buffer(leaf, value_buf, data_ptr, data_len);
+
+                        iterator(ctx, handler, value_buf, data_len);
+next_dir_item:
+                        cur += this_len;
+                        di = (struct btrfs_dir_item *)((char *) di + this_len);
+                }
+
+next_slot:
+                path->slots[0]++;
+        }
+
+        ret = 0;
+out:
+        btrfs_release_path(path);
+        kfree(name_buf);
+        kfree(value_buf);
+
+        return ret;
+}
+
+static void inode_prop_iterator(void *ctx,
+                                const struct prop_handler *handler,
+                                const char *value,
+                                size_t len)
+{
+        struct inode *inode = ctx;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        ret = handler->apply(inode, value, len);
+        if (unlikely(ret))
+                btrfs_warn(root->fs_info,
+                           "error applying prop %s to ino %llu (root %llu): %d",
+                           handler->xattr_name, btrfs_ino(inode),
+                           root->root_key.objectid, ret);
+        else
+                set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
+}
+
+int btrfs_load_inode_props(struct inode *inode, struct btrfs_path *path)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        u64 ino = btrfs_ino(inode);
+        int ret;
+
+        ret = iterate_object_props(root, path, ino, inode_prop_iterator, inode);
+
+        return ret;
+}
+
+static int inherit_props(struct btrfs_trans_handle *trans,
+                         struct inode *inode,
+                         struct inode *parent)
+{
+        const struct prop_handler *h;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        if (!test_bit(BTRFS_INODE_HAS_PROPS,
+                      &BTRFS_I(parent)->runtime_flags))
+                return 0;
+
+        for (h = &prop_handlers[0]; h->xattr_name; h++) {
+                const char *value;
+                u64 num_bytes;
+
+                if (!h->inheritable)
+                        continue;
+
+                value = h->extract(parent);
+                if (!value)
+                        continue;
+
+                num_bytes = btrfs_calc_trans_metadata_size(root, 1);
+                ret = btrfs_block_rsv_add(root, trans->block_rsv,
+                                          num_bytes, BTRFS_RESERVE_NO_FLUSH);
+                if (ret)
+                        goto out;
+                ret = __btrfs_set_prop(trans, inode, h->xattr_name,
+                                       value, strlen(value), 0);
+                btrfs_block_rsv_release(root, trans->block_rsv, num_bytes);
+                if (ret)
+                        goto out;
+        }
+        ret = 0;
+out:
+        return ret;
+}
+
+int btrfs_inode_inherit_props(struct btrfs_trans_handle *trans,
+                              struct inode *inode,
+                              struct inode *dir)
+{
+        if (!dir)
+                return 0;
+
+        return inherit_props(trans, inode, dir);
+}
+
+int btrfs_subvol_inherit_props(struct btrfs_trans_handle *trans,
+                               struct btrfs_root *root,
+                               struct btrfs_root *parent_root)
+{
+        struct btrfs_key key;
+        struct inode *parent_inode, *child_inode;
+        int ret;
+
+        key.objectid = BTRFS_FIRST_FREE_OBJECTID;
+        key.type = BTRFS_INODE_ITEM_KEY;
+        key.offset = 0;
+
+        parent_inode = btrfs_iget(parent_root->fs_info->sb, &key,
+                                  parent_root, NULL);
+        if (IS_ERR(parent_inode))
+                return PTR_ERR(parent_inode);
+
+        child_inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
+        if (IS_ERR(child_inode)) {
+                iput(parent_inode);
+                return PTR_ERR(child_inode);
+        }
+
+        ret = inherit_props(trans, child_inode, parent_inode);
+        iput(child_inode);
+        iput(parent_inode);
+
+        return ret;
+}
+
+static int prop_compression_validate(const char *value, size_t len)
+{
+        if (!strncmp("lzo", value, len))
+                return 0;
+        else if (!strncmp("zlib", value, len))
+                return 0;
+
+        return -EINVAL;
+}
+
+static int prop_compression_apply(struct inode *inode,
+                                  const char *value,
+                                  size_t len)
+{
+        int type;
+
+        if (len == 0) {
+                BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
+                BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
+                BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
+
+                return 0;
+        }
+
+        if (!strncmp("lzo", value, len))
+                type = BTRFS_COMPRESS_LZO;
+        else if (!strncmp("zlib", value, len))
+                type = BTRFS_COMPRESS_ZLIB;
+        else
+                return -EINVAL;
+
+        BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
+        BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
+        BTRFS_I(inode)->force_compress = type;
+
+        return 0;
+}
+
+static const char *prop_compression_extract(struct inode *inode)
+{
+        switch (BTRFS_I(inode)->force_compress) {
+        case BTRFS_COMPRESS_ZLIB:
+                return "zlib";
+        case BTRFS_COMPRESS_LZO:
+                return "lzo";
+        }
+
+        return NULL;
+}
diff --git a/fs/btrfs/props.h b/fs/btrfs/props.h
new file mode 100644
index 000000000000..100f18829d50
--- /dev/null
+++ b/fs/btrfs/props.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2014 Filipe David Borba Manana <fdmanana@gmail.com>
+ *
+ * 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.
+ */
+
+#ifndef __BTRFS_PROPS_H
+#define __BTRFS_PROPS_H
+
+#include "ctree.h"
+
+void __init btrfs_props_init(void);
+
+int btrfs_set_prop(struct inode *inode,
+                   const char *name,
+                   const char *value,
+                   size_t value_len,
+                   int flags);
+
+int btrfs_load_inode_props(struct inode *inode, struct btrfs_path *path);
+
+int btrfs_inode_inherit_props(struct btrfs_trans_handle *trans,
+                              struct inode *inode,
+                              struct inode *dir);
+
+int btrfs_subvol_inherit_props(struct btrfs_trans_handle *trans,
+                               struct btrfs_root *root,
+                               struct btrfs_root *parent_root);
+
+#endif
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 16d7fc751ba8..461e41cb8ca7 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -48,6 +48,7 @@
 #include "transaction.h"
 #include "btrfs_inode.h"
 #include "print-tree.h"
+#include "props.h"
 #include "xattr.h"
 #include "volumes.h"
 #include "export.h"
@@ -1865,6 +1866,8 @@ static int __init init_btrfs_fs(void)
 {
         int err;
 
+        btrfs_props_init();
+
         err = btrfs_init_sysfs();
         if (err)
                 return err;
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 05740b9789e4..4b33765add38 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -27,6 +27,7 @@
 #include "transaction.h"
 #include "xattr.h"
 #include "disk-io.h"
+#include "props.h"
 
 
 ssize_t __btrfs_getxattr(struct inode *inode, const char *name,
@@ -331,7 +332,8 @@ static bool btrfs_is_valid_xattr(const char *name)
                         XATTR_SECURITY_PREFIX_LEN) ||
                !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) ||
                !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) ||
-               !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
+               !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) ||
+                !strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN);
 }
 
 ssize_t btrfs_getxattr(struct dentry *dentry, const char *name,
@@ -373,6 +375,10 @@ int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
         if (!btrfs_is_valid_xattr(name))
                 return -EOPNOTSUPP;
 
+        if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
+                return btrfs_set_prop(dentry->d_inode, name,
+                                      value, size, flags);
+
         if (size == 0)
                 value = "";  /* empty EA, do not remove */
 
@@ -402,6 +408,10 @@ int btrfs_removexattr(struct dentry *dentry, const char *name)
         if (!btrfs_is_valid_xattr(name))
                 return -EOPNOTSUPP;
 
+        if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
+                return btrfs_set_prop(dentry->d_inode, name,
+                                      NULL, 0, XATTR_REPLACE);
+
         return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0,
                                 XATTR_REPLACE);
 }
diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h
index e4629b93bdd6..40bbc04b6f81 100644
--- a/include/uapi/linux/xattr.h
+++ b/include/uapi/linux/xattr.h
@@ -20,6 +20,9 @@
 #define XATTR_MAC_OSX_PREFIX "osx."
 #define XATTR_MAC_OSX_PREFIX_LEN (sizeof(XATTR_MAC_OSX_PREFIX) - 1)
 
+#define XATTR_BTRFS_PREFIX "btrfs."
+#define XATTR_BTRFS_PREFIX_LEN (sizeof(XATTR_BTRFS_PREFIX) - 1)
+
 #define XATTR_SECURITY_PREFIX   "security."
 #define XATTR_SECURITY_PREFIX_LEN (sizeof(XATTR_SECURITY_PREFIX) - 1)