15103e947SJosef Bacik /* 25103e947SJosef Bacik * Copyright (C) 2007 Red Hat. All rights reserved. 35103e947SJosef Bacik * 45103e947SJosef Bacik * This program is free software; you can redistribute it and/or 55103e947SJosef Bacik * modify it under the terms of the GNU General Public 65103e947SJosef Bacik * License v2 as published by the Free Software Foundation. 75103e947SJosef Bacik * 85103e947SJosef Bacik * This program is distributed in the hope that it will be useful, 95103e947SJosef Bacik * but WITHOUT ANY WARRANTY; without even the implied warranty of 105103e947SJosef Bacik * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 115103e947SJosef Bacik * General Public License for more details. 125103e947SJosef Bacik * 135103e947SJosef Bacik * You should have received a copy of the GNU General Public 145103e947SJosef Bacik * License along with this program; if not, write to the 155103e947SJosef Bacik * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 165103e947SJosef Bacik * Boston, MA 021110-1307, USA. 175103e947SJosef Bacik */ 185103e947SJosef Bacik 195103e947SJosef Bacik #include <linux/init.h> 205103e947SJosef Bacik #include <linux/fs.h> 215103e947SJosef Bacik #include <linux/slab.h> 225103e947SJosef Bacik #include <linux/rwsem.h> 235103e947SJosef Bacik #include <linux/xattr.h> 240279b4cdSJim Owens #include <linux/security.h> 255103e947SJosef Bacik #include "ctree.h" 265103e947SJosef Bacik #include "btrfs_inode.h" 275103e947SJosef Bacik #include "transaction.h" 285103e947SJosef Bacik #include "xattr.h" 295103e947SJosef Bacik #include "disk-io.h" 3033268eafSJosef Bacik 3133268eafSJosef Bacik 3295819c05SChristoph Hellwig ssize_t __btrfs_getxattr(struct inode *inode, const char *name, 3395819c05SChristoph Hellwig void *buffer, size_t size) 345103e947SJosef Bacik { 355103e947SJosef Bacik struct btrfs_dir_item *di; 365103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 375103e947SJosef Bacik struct btrfs_path *path; 385103e947SJosef Bacik struct extent_buffer *leaf; 395103e947SJosef Bacik int ret = 0; 405103e947SJosef Bacik unsigned long data_ptr; 415103e947SJosef Bacik 425103e947SJosef Bacik path = btrfs_alloc_path(); 4395819c05SChristoph Hellwig if (!path) 445103e947SJosef Bacik return -ENOMEM; 455103e947SJosef Bacik 465103e947SJosef Bacik /* lookup the xattr by name */ 4733345d01SLi Zefan di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode), name, 485103e947SJosef Bacik strlen(name), 0); 4907060404SJosef Bacik if (!di) { 505103e947SJosef Bacik ret = -ENODATA; 515103e947SJosef Bacik goto out; 5207060404SJosef Bacik } else if (IS_ERR(di)) { 5307060404SJosef Bacik ret = PTR_ERR(di); 5407060404SJosef Bacik goto out; 555103e947SJosef Bacik } 565103e947SJosef Bacik 575103e947SJosef Bacik leaf = path->nodes[0]; 585103e947SJosef Bacik /* if size is 0, that means we want the size of the attr */ 595103e947SJosef Bacik if (!size) { 605103e947SJosef Bacik ret = btrfs_dir_data_len(leaf, di); 615103e947SJosef Bacik goto out; 625103e947SJosef Bacik } 635103e947SJosef Bacik 645103e947SJosef Bacik /* now get the data out of our dir_item */ 655103e947SJosef Bacik if (btrfs_dir_data_len(leaf, di) > size) { 665103e947SJosef Bacik ret = -ERANGE; 675103e947SJosef Bacik goto out; 685103e947SJosef Bacik } 6907060404SJosef Bacik 7007060404SJosef Bacik /* 7107060404SJosef Bacik * The way things are packed into the leaf is like this 7207060404SJosef Bacik * |struct btrfs_dir_item|name|data| 7307060404SJosef Bacik * where name is the xattr name, so security.foo, and data is the 7407060404SJosef Bacik * content of the xattr. data_ptr points to the location in memory 7507060404SJosef Bacik * where the data starts in the in memory leaf 7607060404SJosef Bacik */ 775103e947SJosef Bacik data_ptr = (unsigned long)((char *)(di + 1) + 785103e947SJosef Bacik btrfs_dir_name_len(leaf, di)); 795103e947SJosef Bacik read_extent_buffer(leaf, buffer, data_ptr, 803acd7ee8SJosef Bacik btrfs_dir_data_len(leaf, di)); 815103e947SJosef Bacik ret = btrfs_dir_data_len(leaf, di); 825103e947SJosef Bacik 835103e947SJosef Bacik out: 845103e947SJosef Bacik btrfs_free_path(path); 855103e947SJosef Bacik return ret; 865103e947SJosef Bacik } 875103e947SJosef Bacik 88f34f57a3SYan, Zheng static int do_setxattr(struct btrfs_trans_handle *trans, 89f34f57a3SYan, Zheng struct inode *inode, const char *name, 9095819c05SChristoph Hellwig const void *value, size_t size, int flags) 915103e947SJosef Bacik { 925103e947SJosef Bacik struct btrfs_dir_item *di; 935103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 945103e947SJosef Bacik struct btrfs_path *path; 95f34f57a3SYan, Zheng size_t name_len = strlen(name); 96f34f57a3SYan, Zheng int ret = 0; 97f34f57a3SYan, Zheng 98f34f57a3SYan, Zheng if (name_len + size > BTRFS_MAX_XATTR_SIZE(root)) 99f34f57a3SYan, Zheng return -ENOSPC; 1005103e947SJosef Bacik 1015103e947SJosef Bacik path = btrfs_alloc_path(); 10295819c05SChristoph Hellwig if (!path) 1035103e947SJosef Bacik return -ENOMEM; 1045103e947SJosef Bacik 105fa09200bSJosef Bacik if (flags & XATTR_REPLACE) { 10633345d01SLi Zefan di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(inode), name, 107fa09200bSJosef Bacik name_len, -1); 1085103e947SJosef Bacik if (IS_ERR(di)) { 1095103e947SJosef Bacik ret = PTR_ERR(di); 1105103e947SJosef Bacik goto out; 111fa09200bSJosef Bacik } else if (!di) { 1125103e947SJosef Bacik ret = -ENODATA; 1135103e947SJosef Bacik goto out; 1145103e947SJosef Bacik } 115fa09200bSJosef Bacik ret = btrfs_delete_one_dir_name(trans, root, path, di); 116fa09200bSJosef Bacik if (ret) 117fa09200bSJosef Bacik goto out; 118fa09200bSJosef Bacik btrfs_release_path(path); 1194815053aSDavid Sterba 1204815053aSDavid Sterba /* 1214815053aSDavid Sterba * remove the attribute 1224815053aSDavid Sterba */ 1234815053aSDavid Sterba if (!value) 1244815053aSDavid Sterba goto out; 12533268eafSJosef Bacik } 1265103e947SJosef Bacik 127fa09200bSJosef Bacik again: 12833345d01SLi Zefan ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(inode), 129f34f57a3SYan, Zheng name, name_len, value, size); 130ed3ee9f4SJosef Bacik /* 131ed3ee9f4SJosef Bacik * If we're setting an xattr to a new value but the new value is say 132ed3ee9f4SJosef Bacik * exactly BTRFS_MAX_XATTR_SIZE, we could end up with EOVERFLOW getting 133ed3ee9f4SJosef Bacik * back from split_leaf. This is because it thinks we'll be extending 134ed3ee9f4SJosef Bacik * the existing item size, but we're asking for enough space to add the 135ed3ee9f4SJosef Bacik * item itself. So if we get EOVERFLOW just set ret to EEXIST and let 136ed3ee9f4SJosef Bacik * the rest of the function figure it out. 137ed3ee9f4SJosef Bacik */ 138ed3ee9f4SJosef Bacik if (ret == -EOVERFLOW) 139ed3ee9f4SJosef Bacik ret = -EEXIST; 140ed3ee9f4SJosef Bacik 141fa09200bSJosef Bacik if (ret == -EEXIST) { 142fa09200bSJosef Bacik if (flags & XATTR_CREATE) 143fa09200bSJosef Bacik goto out; 144fa09200bSJosef Bacik /* 145fa09200bSJosef Bacik * We can't use the path we already have since we won't have the 146fa09200bSJosef Bacik * proper locking for a delete, so release the path and 147fa09200bSJosef Bacik * re-lookup to delete the thing. 148fa09200bSJosef Bacik */ 149fa09200bSJosef Bacik btrfs_release_path(path); 150fa09200bSJosef Bacik di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(inode), 151fa09200bSJosef Bacik name, name_len, -1); 152fa09200bSJosef Bacik if (IS_ERR(di)) { 153fa09200bSJosef Bacik ret = PTR_ERR(di); 154fa09200bSJosef Bacik goto out; 155fa09200bSJosef Bacik } else if (!di) { 156fa09200bSJosef Bacik /* Shouldn't happen but just in case... */ 157fa09200bSJosef Bacik btrfs_release_path(path); 158fa09200bSJosef Bacik goto again; 159fa09200bSJosef Bacik } 160fa09200bSJosef Bacik 161fa09200bSJosef Bacik ret = btrfs_delete_one_dir_name(trans, root, path, di); 162fa09200bSJosef Bacik if (ret) 163fa09200bSJosef Bacik goto out; 164fa09200bSJosef Bacik 165fa09200bSJosef Bacik /* 166fa09200bSJosef Bacik * We have a value to set, so go back and try to insert it now. 167fa09200bSJosef Bacik */ 168fa09200bSJosef Bacik if (value) { 169fa09200bSJosef Bacik btrfs_release_path(path); 170fa09200bSJosef Bacik goto again; 171fa09200bSJosef Bacik } 172fa09200bSJosef Bacik } 1735103e947SJosef Bacik out: 174f34f57a3SYan, Zheng btrfs_free_path(path); 175f34f57a3SYan, Zheng return ret; 1765103e947SJosef Bacik } 1775103e947SJosef Bacik 1784815053aSDavid Sterba /* 1794815053aSDavid Sterba * @value: "" makes the attribute to empty, NULL removes it 1804815053aSDavid Sterba */ 181f34f57a3SYan, Zheng int __btrfs_setxattr(struct btrfs_trans_handle *trans, 182f34f57a3SYan, Zheng struct inode *inode, const char *name, 183f34f57a3SYan, Zheng const void *value, size_t size, int flags) 184f34f57a3SYan, Zheng { 185f34f57a3SYan, Zheng struct btrfs_root *root = BTRFS_I(inode)->root; 186f34f57a3SYan, Zheng int ret; 187f34f57a3SYan, Zheng 188f34f57a3SYan, Zheng if (trans) 189f34f57a3SYan, Zheng return do_setxattr(trans, inode, name, value, size, flags); 190f34f57a3SYan, Zheng 191a22285a6SYan, Zheng trans = btrfs_start_transaction(root, 2); 192a22285a6SYan, Zheng if (IS_ERR(trans)) 193a22285a6SYan, Zheng return PTR_ERR(trans); 194f34f57a3SYan, Zheng 195f34f57a3SYan, Zheng ret = do_setxattr(trans, inode, name, value, size, flags); 196f34f57a3SYan, Zheng if (ret) 197f34f57a3SYan, Zheng goto out; 198f34f57a3SYan, Zheng 1990c4d2d95SJosef Bacik inode_inc_iversion(inode); 200f34f57a3SYan, Zheng inode->i_ctime = CURRENT_TIME; 201f34f57a3SYan, Zheng ret = btrfs_update_inode(trans, root, inode); 202f34f57a3SYan, Zheng BUG_ON(ret); 203f34f57a3SYan, Zheng out: 2047ad85bb7SJosef Bacik btrfs_end_transaction(trans, root); 2055103e947SJosef Bacik return ret; 2065103e947SJosef Bacik } 2075103e947SJosef Bacik 2085103e947SJosef Bacik ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size) 2095103e947SJosef Bacik { 2105103e947SJosef Bacik struct btrfs_key key, found_key; 2115103e947SJosef Bacik struct inode *inode = dentry->d_inode; 2125103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 2135103e947SJosef Bacik struct btrfs_path *path; 2145103e947SJosef Bacik struct extent_buffer *leaf; 2155103e947SJosef Bacik struct btrfs_dir_item *di; 2162e6a0035SLi Zefan int ret = 0, slot; 217eaa47d86SChristoph Hellwig size_t total_size = 0, size_left = size; 2185103e947SJosef Bacik unsigned long name_ptr; 219eaa47d86SChristoph Hellwig size_t name_len; 2205103e947SJosef Bacik 2215103e947SJosef Bacik /* 2225103e947SJosef Bacik * ok we want all objects associated with this id. 2235103e947SJosef Bacik * NOTE: we set key.offset = 0; because we want to start with the 2245103e947SJosef Bacik * first xattr that we find and walk forward 2255103e947SJosef Bacik */ 22633345d01SLi Zefan key.objectid = btrfs_ino(inode); 2275103e947SJosef Bacik btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY); 2285103e947SJosef Bacik key.offset = 0; 2295103e947SJosef Bacik 2305103e947SJosef Bacik path = btrfs_alloc_path(); 2315103e947SJosef Bacik if (!path) 2325103e947SJosef Bacik return -ENOMEM; 2331caf9342SJosef Bacik path->reada = 2; 2345103e947SJosef Bacik 2355103e947SJosef Bacik /* search for our xattrs */ 2365103e947SJosef Bacik ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2375103e947SJosef Bacik if (ret < 0) 2385103e947SJosef Bacik goto err; 2392e6a0035SLi Zefan 2405103e947SJosef Bacik while (1) { 2415103e947SJosef Bacik leaf = path->nodes[0]; 2425103e947SJosef Bacik slot = path->slots[0]; 2435103e947SJosef Bacik 2445103e947SJosef Bacik /* this is where we start walking through the path */ 2452e6a0035SLi Zefan if (slot >= btrfs_header_nritems(leaf)) { 2465103e947SJosef Bacik /* 2475103e947SJosef Bacik * if we've reached the last slot in this leaf we need 2485103e947SJosef Bacik * to go to the next leaf and reset everything 2495103e947SJosef Bacik */ 2505103e947SJosef Bacik ret = btrfs_next_leaf(root, path); 2512e6a0035SLi Zefan if (ret < 0) 2522e6a0035SLi Zefan goto err; 2532e6a0035SLi Zefan else if (ret > 0) 2545103e947SJosef Bacik break; 2552e6a0035SLi Zefan continue; 2565103e947SJosef Bacik } 2575103e947SJosef Bacik 2585103e947SJosef Bacik btrfs_item_key_to_cpu(leaf, &found_key, slot); 2595103e947SJosef Bacik 2605103e947SJosef Bacik /* check to make sure this item is what we want */ 2615103e947SJosef Bacik if (found_key.objectid != key.objectid) 2625103e947SJosef Bacik break; 2635103e947SJosef Bacik if (btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY) 2645103e947SJosef Bacik break; 2655103e947SJosef Bacik 2665103e947SJosef Bacik di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); 26722a94d44SJosef Bacik if (verify_dir_item(root, leaf, di)) 26822a94d44SJosef Bacik continue; 2695103e947SJosef Bacik 270eaa47d86SChristoph Hellwig name_len = btrfs_dir_name_len(leaf, di); 271eaa47d86SChristoph Hellwig total_size += name_len + 1; 2725103e947SJosef Bacik 2735103e947SJosef Bacik /* we are just looking for how big our buffer needs to be */ 2745103e947SJosef Bacik if (!size) 2752e6a0035SLi Zefan goto next; 2765103e947SJosef Bacik 277eaa47d86SChristoph Hellwig if (!buffer || (name_len + 1) > size_left) { 2785103e947SJosef Bacik ret = -ERANGE; 279b16281c3SYehuda Sadeh Weinraub goto err; 2805103e947SJosef Bacik } 2815103e947SJosef Bacik 282eaa47d86SChristoph Hellwig name_ptr = (unsigned long)(di + 1); 283eaa47d86SChristoph Hellwig read_extent_buffer(leaf, buffer, name_ptr, name_len); 284eaa47d86SChristoph Hellwig buffer[name_len] = '\0'; 285eaa47d86SChristoph Hellwig 286eaa47d86SChristoph Hellwig size_left -= name_len + 1; 287eaa47d86SChristoph Hellwig buffer += name_len + 1; 2882e6a0035SLi Zefan next: 2892e6a0035SLi Zefan path->slots[0]++; 2905103e947SJosef Bacik } 2915103e947SJosef Bacik ret = total_size; 2925103e947SJosef Bacik 2935103e947SJosef Bacik err: 2945103e947SJosef Bacik btrfs_free_path(path); 2955103e947SJosef Bacik 2965103e947SJosef Bacik return ret; 2975103e947SJosef Bacik } 2985103e947SJosef Bacik 2995103e947SJosef Bacik /* 30095819c05SChristoph Hellwig * List of handlers for synthetic system.* attributes. All real ondisk 30195819c05SChristoph Hellwig * attributes are handled directly. 3025103e947SJosef Bacik */ 303f01cbd3fSStephen Hemminger const struct xattr_handler *btrfs_xattr_handlers[] = { 3040eda294dSChris Mason #ifdef CONFIG_BTRFS_FS_POSIX_ACL 30595819c05SChristoph Hellwig &btrfs_xattr_acl_access_handler, 30695819c05SChristoph Hellwig &btrfs_xattr_acl_default_handler, 30795819c05SChristoph Hellwig #endif 30895819c05SChristoph Hellwig NULL, 30995819c05SChristoph Hellwig }; 31095819c05SChristoph Hellwig 31195819c05SChristoph Hellwig /* 31295819c05SChristoph Hellwig * Check if the attribute is in a supported namespace. 31395819c05SChristoph Hellwig * 31495819c05SChristoph Hellwig * This applied after the check for the synthetic attributes in the system 31595819c05SChristoph Hellwig * namespace. 31695819c05SChristoph Hellwig */ 31795819c05SChristoph Hellwig static bool btrfs_is_valid_xattr(const char *name) 31895819c05SChristoph Hellwig { 319d397712bSChris Mason return !strncmp(name, XATTR_SECURITY_PREFIX, 320d397712bSChris Mason XATTR_SECURITY_PREFIX_LEN) || 32195819c05SChristoph Hellwig !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) || 32295819c05SChristoph Hellwig !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) || 32395819c05SChristoph Hellwig !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 32469a32ac5SChris Mason } 32569a32ac5SChris Mason 32695819c05SChristoph Hellwig ssize_t btrfs_getxattr(struct dentry *dentry, const char *name, 32795819c05SChristoph Hellwig void *buffer, size_t size) 32895819c05SChristoph Hellwig { 32995819c05SChristoph Hellwig /* 33095819c05SChristoph Hellwig * If this is a request for a synthetic attribute in the system.* 33195819c05SChristoph Hellwig * namespace use the generic infrastructure to resolve a handler 33295819c05SChristoph Hellwig * for it via sb->s_xattr. 33395819c05SChristoph Hellwig */ 33495819c05SChristoph Hellwig if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 33595819c05SChristoph Hellwig return generic_getxattr(dentry, name, buffer, size); 3365103e947SJosef Bacik 33795819c05SChristoph Hellwig if (!btrfs_is_valid_xattr(name)) 33895819c05SChristoph Hellwig return -EOPNOTSUPP; 33995819c05SChristoph Hellwig return __btrfs_getxattr(dentry->d_inode, name, buffer, size); 34095819c05SChristoph Hellwig } 3415103e947SJosef Bacik 34295819c05SChristoph Hellwig int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value, 34395819c05SChristoph Hellwig size_t size, int flags) 34495819c05SChristoph Hellwig { 345b83cc969SLi Zefan struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root; 346b83cc969SLi Zefan 347b83cc969SLi Zefan /* 348b83cc969SLi Zefan * The permission on security.* and system.* is not checked 349b83cc969SLi Zefan * in permission(). 350b83cc969SLi Zefan */ 351b83cc969SLi Zefan if (btrfs_root_readonly(root)) 352b83cc969SLi Zefan return -EROFS; 353b83cc969SLi Zefan 35495819c05SChristoph Hellwig /* 35595819c05SChristoph Hellwig * If this is a request for a synthetic attribute in the system.* 35695819c05SChristoph Hellwig * namespace use the generic infrastructure to resolve a handler 35795819c05SChristoph Hellwig * for it via sb->s_xattr. 35895819c05SChristoph Hellwig */ 35995819c05SChristoph Hellwig if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 36095819c05SChristoph Hellwig return generic_setxattr(dentry, name, value, size, flags); 3615103e947SJosef Bacik 36295819c05SChristoph Hellwig if (!btrfs_is_valid_xattr(name)) 36395819c05SChristoph Hellwig return -EOPNOTSUPP; 3645103e947SJosef Bacik 36595819c05SChristoph Hellwig if (size == 0) 36695819c05SChristoph Hellwig value = ""; /* empty EA, do not remove */ 367f34f57a3SYan, Zheng 368f34f57a3SYan, Zheng return __btrfs_setxattr(NULL, dentry->d_inode, name, value, size, 369f34f57a3SYan, Zheng flags); 37095819c05SChristoph Hellwig } 37195819c05SChristoph Hellwig 37295819c05SChristoph Hellwig int btrfs_removexattr(struct dentry *dentry, const char *name) 37395819c05SChristoph Hellwig { 374b83cc969SLi Zefan struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root; 375b83cc969SLi Zefan 376b83cc969SLi Zefan /* 377b83cc969SLi Zefan * The permission on security.* and system.* is not checked 378b83cc969SLi Zefan * in permission(). 379b83cc969SLi Zefan */ 380b83cc969SLi Zefan if (btrfs_root_readonly(root)) 381b83cc969SLi Zefan return -EROFS; 382b83cc969SLi Zefan 38395819c05SChristoph Hellwig /* 38495819c05SChristoph Hellwig * If this is a request for a synthetic attribute in the system.* 38595819c05SChristoph Hellwig * namespace use the generic infrastructure to resolve a handler 38695819c05SChristoph Hellwig * for it via sb->s_xattr. 38795819c05SChristoph Hellwig */ 38895819c05SChristoph Hellwig if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 38995819c05SChristoph Hellwig return generic_removexattr(dentry, name); 39095819c05SChristoph Hellwig 39195819c05SChristoph Hellwig if (!btrfs_is_valid_xattr(name)) 39295819c05SChristoph Hellwig return -EOPNOTSUPP; 393f34f57a3SYan, Zheng 394f34f57a3SYan, Zheng return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0, 395f34f57a3SYan, Zheng XATTR_REPLACE); 39695819c05SChristoph Hellwig } 3970279b4cdSJim Owens 3989d8f13baSMimi Zohar int btrfs_initxattrs(struct inode *inode, const struct xattr *xattr_array, 3999d8f13baSMimi Zohar void *fs_info) 4009d8f13baSMimi Zohar { 4019d8f13baSMimi Zohar const struct xattr *xattr; 4029d8f13baSMimi Zohar struct btrfs_trans_handle *trans = fs_info; 4039d8f13baSMimi Zohar char *name; 4049d8f13baSMimi Zohar int err = 0; 4059d8f13baSMimi Zohar 4069d8f13baSMimi Zohar for (xattr = xattr_array; xattr->name != NULL; xattr++) { 4079d8f13baSMimi Zohar name = kmalloc(XATTR_SECURITY_PREFIX_LEN + 4089d8f13baSMimi Zohar strlen(xattr->name) + 1, GFP_NOFS); 4099d8f13baSMimi Zohar if (!name) { 4109d8f13baSMimi Zohar err = -ENOMEM; 4119d8f13baSMimi Zohar break; 4129d8f13baSMimi Zohar } 4139d8f13baSMimi Zohar strcpy(name, XATTR_SECURITY_PREFIX); 4149d8f13baSMimi Zohar strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name); 4159d8f13baSMimi Zohar err = __btrfs_setxattr(trans, inode, name, 4169d8f13baSMimi Zohar xattr->value, xattr->value_len, 0); 4179d8f13baSMimi Zohar kfree(name); 4189d8f13baSMimi Zohar if (err < 0) 4199d8f13baSMimi Zohar break; 4209d8f13baSMimi Zohar } 4219d8f13baSMimi Zohar return err; 4229d8f13baSMimi Zohar } 4239d8f13baSMimi Zohar 424f34f57a3SYan, Zheng int btrfs_xattr_security_init(struct btrfs_trans_handle *trans, 4252a7dba39SEric Paris struct inode *inode, struct inode *dir, 4262a7dba39SEric Paris const struct qstr *qstr) 4270279b4cdSJim Owens { 4289d8f13baSMimi Zohar return security_inode_init_security(inode, dir, qstr, 4299d8f13baSMimi Zohar &btrfs_initxattrs, trans); 4300279b4cdSJim Owens } 431