1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 25103e947SJosef Bacik /* 35103e947SJosef Bacik * Copyright (C) 2007 Red Hat. All rights reserved. 45103e947SJosef Bacik */ 55103e947SJosef Bacik 65103e947SJosef Bacik #include <linux/init.h> 75103e947SJosef Bacik #include <linux/fs.h> 85103e947SJosef Bacik #include <linux/slab.h> 95103e947SJosef Bacik #include <linux/rwsem.h> 105103e947SJosef Bacik #include <linux/xattr.h> 110279b4cdSJim Owens #include <linux/security.h> 12996a710dSChristoph Hellwig #include <linux/posix_acl_xattr.h> 13ae5e165dSJeff Layton #include <linux/iversion.h> 14827aa18eSFilipe Manana #include <linux/sched/mm.h> 155103e947SJosef Bacik #include "ctree.h" 16ec8eb376SJosef Bacik #include "fs.h" 17ec8eb376SJosef Bacik #include "messages.h" 185103e947SJosef Bacik #include "btrfs_inode.h" 195103e947SJosef Bacik #include "transaction.h" 205103e947SJosef Bacik #include "xattr.h" 215103e947SJosef Bacik #include "disk-io.h" 2263541927SFilipe David Borba Manana #include "props.h" 235f5bc6b1SFilipe Manana #include "locking.h" 24*07e81dc9SJosef Bacik #include "accessors.h" 2533268eafSJosef Bacik 26bcadd705SDavid Sterba int btrfs_getxattr(struct inode *inode, const char *name, 2795819c05SChristoph Hellwig void *buffer, size_t size) 285103e947SJosef Bacik { 295103e947SJosef Bacik struct btrfs_dir_item *di; 305103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 315103e947SJosef Bacik struct btrfs_path *path; 325103e947SJosef Bacik struct extent_buffer *leaf; 335103e947SJosef Bacik int ret = 0; 345103e947SJosef Bacik unsigned long data_ptr; 355103e947SJosef Bacik 365103e947SJosef Bacik path = btrfs_alloc_path(); 3795819c05SChristoph Hellwig if (!path) 385103e947SJosef Bacik return -ENOMEM; 395103e947SJosef Bacik 405103e947SJosef Bacik /* lookup the xattr by name */ 41f85b7379SDavid Sterba di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(BTRFS_I(inode)), 42f85b7379SDavid Sterba name, strlen(name), 0); 4307060404SJosef Bacik if (!di) { 445103e947SJosef Bacik ret = -ENODATA; 455103e947SJosef Bacik goto out; 4607060404SJosef Bacik } else if (IS_ERR(di)) { 4707060404SJosef Bacik ret = PTR_ERR(di); 4807060404SJosef Bacik goto out; 495103e947SJosef Bacik } 505103e947SJosef Bacik 515103e947SJosef Bacik leaf = path->nodes[0]; 525103e947SJosef Bacik /* if size is 0, that means we want the size of the attr */ 535103e947SJosef Bacik if (!size) { 545103e947SJosef Bacik ret = btrfs_dir_data_len(leaf, di); 555103e947SJosef Bacik goto out; 565103e947SJosef Bacik } 575103e947SJosef Bacik 585103e947SJosef Bacik /* now get the data out of our dir_item */ 595103e947SJosef Bacik if (btrfs_dir_data_len(leaf, di) > size) { 605103e947SJosef Bacik ret = -ERANGE; 615103e947SJosef Bacik goto out; 625103e947SJosef Bacik } 6307060404SJosef Bacik 6407060404SJosef Bacik /* 6507060404SJosef Bacik * The way things are packed into the leaf is like this 6607060404SJosef Bacik * |struct btrfs_dir_item|name|data| 6707060404SJosef Bacik * where name is the xattr name, so security.foo, and data is the 6807060404SJosef Bacik * content of the xattr. data_ptr points to the location in memory 6907060404SJosef Bacik * where the data starts in the in memory leaf 7007060404SJosef Bacik */ 715103e947SJosef Bacik data_ptr = (unsigned long)((char *)(di + 1) + 725103e947SJosef Bacik btrfs_dir_name_len(leaf, di)); 735103e947SJosef Bacik read_extent_buffer(leaf, buffer, data_ptr, 743acd7ee8SJosef Bacik btrfs_dir_data_len(leaf, di)); 755103e947SJosef Bacik ret = btrfs_dir_data_len(leaf, di); 765103e947SJosef Bacik 775103e947SJosef Bacik out: 785103e947SJosef Bacik btrfs_free_path(path); 795103e947SJosef Bacik return ret; 805103e947SJosef Bacik } 815103e947SJosef Bacik 823e125a74SAnand Jain int btrfs_setxattr(struct btrfs_trans_handle *trans, struct inode *inode, 833e125a74SAnand Jain const char *name, const void *value, size_t size, int flags) 845103e947SJosef Bacik { 855f5bc6b1SFilipe Manana struct btrfs_dir_item *di = NULL; 865103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 872ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 885103e947SJosef Bacik struct btrfs_path *path; 89f34f57a3SYan, Zheng size_t name_len = strlen(name); 90f34f57a3SYan, Zheng int ret = 0; 91f34f57a3SYan, Zheng 9204e6863bSAnand Jain ASSERT(trans); 9304e6863bSAnand Jain 94da17066cSJeff Mahoney if (name_len + size > BTRFS_MAX_XATTR_SIZE(root->fs_info)) 95f34f57a3SYan, Zheng return -ENOSPC; 965103e947SJosef Bacik 975103e947SJosef Bacik path = btrfs_alloc_path(); 9895819c05SChristoph Hellwig if (!path) 995103e947SJosef Bacik return -ENOMEM; 1005f5bc6b1SFilipe Manana path->skip_release_on_error = 1; 1015103e947SJosef Bacik 1025f5bc6b1SFilipe Manana if (!value) { 103f85b7379SDavid Sterba di = btrfs_lookup_xattr(trans, root, path, 104f85b7379SDavid Sterba btrfs_ino(BTRFS_I(inode)), name, name_len, -1); 1055f5bc6b1SFilipe Manana if (!di && (flags & XATTR_REPLACE)) 1065f5bc6b1SFilipe Manana ret = -ENODATA; 1075cdf83edSFilipe Manana else if (IS_ERR(di)) 1085cdf83edSFilipe Manana ret = PTR_ERR(di); 1095f5bc6b1SFilipe Manana else if (di) 1105f5bc6b1SFilipe Manana ret = btrfs_delete_one_dir_name(trans, root, path, di); 1115103e947SJosef Bacik goto out; 1125f5bc6b1SFilipe Manana } 1135f5bc6b1SFilipe Manana 1145f5bc6b1SFilipe Manana /* 1155f5bc6b1SFilipe Manana * For a replace we can't just do the insert blindly. 1165f5bc6b1SFilipe Manana * Do a lookup first (read-only btrfs_search_slot), and return if xattr 1175f5bc6b1SFilipe Manana * doesn't exist. If it exists, fall down below to the insert/replace 1185f5bc6b1SFilipe Manana * path - we can't race with a concurrent xattr delete, because the VFS 1195f5bc6b1SFilipe Manana * locks the inode's i_mutex before calling setxattr or removexattr. 1205f5bc6b1SFilipe Manana */ 1215f5bc6b1SFilipe Manana if (flags & XATTR_REPLACE) { 1225955102cSAl Viro ASSERT(inode_is_locked(inode)); 123f85b7379SDavid Sterba di = btrfs_lookup_xattr(NULL, root, path, 124f85b7379SDavid Sterba btrfs_ino(BTRFS_I(inode)), name, name_len, 0); 1255cdf83edSFilipe Manana if (!di) 1265103e947SJosef Bacik ret = -ENODATA; 1275cdf83edSFilipe Manana else if (IS_ERR(di)) 1285cdf83edSFilipe Manana ret = PTR_ERR(di); 1295cdf83edSFilipe Manana if (ret) 1305103e947SJosef Bacik goto out; 131fa09200bSJosef Bacik btrfs_release_path(path); 1325f5bc6b1SFilipe Manana di = NULL; 13333268eafSJosef Bacik } 1345103e947SJosef Bacik 1354a0cc7caSNikolay Borisov ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(BTRFS_I(inode)), 136f34f57a3SYan, Zheng name, name_len, value, size); 1375f5bc6b1SFilipe Manana if (ret == -EOVERFLOW) { 138ed3ee9f4SJosef Bacik /* 1395f5bc6b1SFilipe Manana * We have an existing item in a leaf, split_leaf couldn't 1405f5bc6b1SFilipe Manana * expand it. That item might have or not a dir_item that 1415f5bc6b1SFilipe Manana * matches our target xattr, so lets check. 142ed3ee9f4SJosef Bacik */ 1435f5bc6b1SFilipe Manana ret = 0; 14449d0c642SFilipe Manana btrfs_assert_tree_write_locked(path->nodes[0]); 1452ff7e61eSJeff Mahoney di = btrfs_match_dir_item_name(fs_info, path, name, name_len); 1465f5bc6b1SFilipe Manana if (!di && !(flags & XATTR_REPLACE)) { 1475f5bc6b1SFilipe Manana ret = -ENOSPC; 148fa09200bSJosef Bacik goto out; 1495f5bc6b1SFilipe Manana } 1505f5bc6b1SFilipe Manana } else if (ret == -EEXIST) { 1515f5bc6b1SFilipe Manana ret = 0; 1522ff7e61eSJeff Mahoney di = btrfs_match_dir_item_name(fs_info, path, name, name_len); 1535f5bc6b1SFilipe Manana ASSERT(di); /* logic error */ 1545f5bc6b1SFilipe Manana } else if (ret) { 155fa09200bSJosef Bacik goto out; 156fa09200bSJosef Bacik } 157fa09200bSJosef Bacik 1585f5bc6b1SFilipe Manana if (di && (flags & XATTR_CREATE)) { 1595f5bc6b1SFilipe Manana ret = -EEXIST; 1605f5bc6b1SFilipe Manana goto out; 1615f5bc6b1SFilipe Manana } 1625f5bc6b1SFilipe Manana 1635f5bc6b1SFilipe Manana if (di) { 1645f5bc6b1SFilipe Manana /* 1655f5bc6b1SFilipe Manana * We're doing a replace, and it must be atomic, that is, at 1665f5bc6b1SFilipe Manana * any point in time we have either the old or the new xattr 1675f5bc6b1SFilipe Manana * value in the tree. We don't want readers (getxattr and 1685f5bc6b1SFilipe Manana * listxattrs) to miss a value, this is specially important 1695f5bc6b1SFilipe Manana * for ACLs. 1705f5bc6b1SFilipe Manana */ 1715f5bc6b1SFilipe Manana const int slot = path->slots[0]; 1725f5bc6b1SFilipe Manana struct extent_buffer *leaf = path->nodes[0]; 1735f5bc6b1SFilipe Manana const u16 old_data_len = btrfs_dir_data_len(leaf, di); 1743212fa14SJosef Bacik const u32 item_size = btrfs_item_size(leaf, slot); 1755f5bc6b1SFilipe Manana const u32 data_size = sizeof(*di) + name_len + size; 1765f5bc6b1SFilipe Manana unsigned long data_ptr; 1775f5bc6b1SFilipe Manana char *ptr; 1785f5bc6b1SFilipe Manana 1795f5bc6b1SFilipe Manana if (size > old_data_len) { 180e902baacSDavid Sterba if (btrfs_leaf_free_space(leaf) < 1815f5bc6b1SFilipe Manana (size - old_data_len)) { 1825f5bc6b1SFilipe Manana ret = -ENOSPC; 1835f5bc6b1SFilipe Manana goto out; 1845f5bc6b1SFilipe Manana } 1855f5bc6b1SFilipe Manana } 1865f5bc6b1SFilipe Manana 1875f5bc6b1SFilipe Manana if (old_data_len + name_len + sizeof(*di) == item_size) { 1885f5bc6b1SFilipe Manana /* No other xattrs packed in the same leaf item. */ 1895f5bc6b1SFilipe Manana if (size > old_data_len) 190c71dd880SDavid Sterba btrfs_extend_item(path, size - old_data_len); 1915f5bc6b1SFilipe Manana else if (size < old_data_len) 19278ac4f9eSDavid Sterba btrfs_truncate_item(path, data_size, 1); 1935f5bc6b1SFilipe Manana } else { 1945f5bc6b1SFilipe Manana /* There are other xattrs packed in the same item. */ 195fa09200bSJosef Bacik ret = btrfs_delete_one_dir_name(trans, root, path, di); 196fa09200bSJosef Bacik if (ret) 197fa09200bSJosef Bacik goto out; 198c71dd880SDavid Sterba btrfs_extend_item(path, data_size); 199fa09200bSJosef Bacik } 2005f5bc6b1SFilipe Manana 2015f5bc6b1SFilipe Manana ptr = btrfs_item_ptr(leaf, slot, char); 2023212fa14SJosef Bacik ptr += btrfs_item_size(leaf, slot) - data_size; 2035f5bc6b1SFilipe Manana di = (struct btrfs_dir_item *)ptr; 2045f5bc6b1SFilipe Manana btrfs_set_dir_data_len(leaf, di, size); 2055f5bc6b1SFilipe Manana data_ptr = ((unsigned long)(di + 1)) + name_len; 2065f5bc6b1SFilipe Manana write_extent_buffer(leaf, value, data_ptr, size); 2075f5bc6b1SFilipe Manana btrfs_mark_buffer_dirty(leaf); 2085f5bc6b1SFilipe Manana } else { 2095f5bc6b1SFilipe Manana /* 2105f5bc6b1SFilipe Manana * Insert, and we had space for the xattr, so path->slots[0] is 2115f5bc6b1SFilipe Manana * where our xattr dir_item is and btrfs_insert_xattr_item() 2125f5bc6b1SFilipe Manana * filled it. 2135f5bc6b1SFilipe Manana */ 214fa09200bSJosef Bacik } 2155103e947SJosef Bacik out: 216f34f57a3SYan, Zheng btrfs_free_path(path); 217f2f121abSFilipe Manana if (!ret) { 2183763771cSFilipe Manana set_bit(BTRFS_INODE_COPY_EVERYTHING, 2193763771cSFilipe Manana &BTRFS_I(inode)->runtime_flags); 220f2f121abSFilipe Manana clear_bit(BTRFS_INODE_NO_XATTRS, &BTRFS_I(inode)->runtime_flags); 221f2f121abSFilipe Manana } 222f34f57a3SYan, Zheng return ret; 2235103e947SJosef Bacik } 2245103e947SJosef Bacik 2254815053aSDavid Sterba /* 2264815053aSDavid Sterba * @value: "" makes the attribute to empty, NULL removes it 2274815053aSDavid Sterba */ 228e3de9b15SAnand Jain int btrfs_setxattr_trans(struct inode *inode, const char *name, 229f34f57a3SYan, Zheng const void *value, size_t size, int flags) 230f34f57a3SYan, Zheng { 231f34f57a3SYan, Zheng struct btrfs_root *root = BTRFS_I(inode)->root; 232e3de9b15SAnand Jain struct btrfs_trans_handle *trans; 233fd57a98dSFilipe Manana const bool start_trans = (current->journal_info == NULL); 234f34f57a3SYan, Zheng int ret; 235f34f57a3SYan, Zheng 236fd57a98dSFilipe Manana if (start_trans) { 237fd57a98dSFilipe Manana /* 238fd57a98dSFilipe Manana * 1 unit for inserting/updating/deleting the xattr 239fd57a98dSFilipe Manana * 1 unit for the inode item update 240fd57a98dSFilipe Manana */ 241a22285a6SYan, Zheng trans = btrfs_start_transaction(root, 2); 242a22285a6SYan, Zheng if (IS_ERR(trans)) 243a22285a6SYan, Zheng return PTR_ERR(trans); 244fd57a98dSFilipe Manana } else { 245fd57a98dSFilipe Manana /* 246fd57a98dSFilipe Manana * This can happen when smack is enabled and a directory is being 247fd57a98dSFilipe Manana * created. It happens through d_instantiate_new(), which calls 248fd57a98dSFilipe Manana * smack_d_instantiate(), which in turn calls __vfs_setxattr() to 249fd57a98dSFilipe Manana * set the transmute xattr (XATTR_NAME_SMACKTRANSMUTE) on the 250fd57a98dSFilipe Manana * inode. We have already reserved space for the xattr and inode 251fd57a98dSFilipe Manana * update at btrfs_mkdir(), so just use the transaction handle. 252fd57a98dSFilipe Manana * We don't join or start a transaction, as that will reset the 253fd57a98dSFilipe Manana * block_rsv of the handle and trigger a warning for the start 254fd57a98dSFilipe Manana * case. 255fd57a98dSFilipe Manana */ 256fd57a98dSFilipe Manana ASSERT(strncmp(name, XATTR_SECURITY_PREFIX, 257fd57a98dSFilipe Manana XATTR_SECURITY_PREFIX_LEN) == 0); 258fd57a98dSFilipe Manana trans = current->journal_info; 259fd57a98dSFilipe Manana } 260f34f57a3SYan, Zheng 2612d74fa3eSAnand Jain ret = btrfs_setxattr(trans, inode, name, value, size, flags); 262f34f57a3SYan, Zheng if (ret) 263f34f57a3SYan, Zheng goto out; 264f34f57a3SYan, Zheng 2650c4d2d95SJosef Bacik inode_inc_iversion(inode); 266c2050a45SDeepa Dinamani inode->i_ctime = current_time(inode); 2679a56fcd1SNikolay Borisov ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); 268193b4e83SFilipe Manana if (ret) 269193b4e83SFilipe Manana btrfs_abort_transaction(trans, ret); 270f34f57a3SYan, Zheng out: 271fd57a98dSFilipe Manana if (start_trans) 2723a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2735103e947SJosef Bacik return ret; 2745103e947SJosef Bacik } 2755103e947SJosef Bacik 2765103e947SJosef Bacik ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size) 2775103e947SJosef Bacik { 278184b3d19SGabriel Niebler struct btrfs_key found_key; 279daac7ba6SFilipe Manana struct btrfs_key key; 2802b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 2815103e947SJosef Bacik struct btrfs_root *root = BTRFS_I(inode)->root; 2825103e947SJosef Bacik struct btrfs_path *path; 283184b3d19SGabriel Niebler int iter_ret = 0; 284daac7ba6SFilipe Manana int ret = 0; 285eaa47d86SChristoph Hellwig size_t total_size = 0, size_left = size; 2865103e947SJosef Bacik 2875103e947SJosef Bacik /* 2885103e947SJosef Bacik * ok we want all objects associated with this id. 2895103e947SJosef Bacik * NOTE: we set key.offset = 0; because we want to start with the 2905103e947SJosef Bacik * first xattr that we find and walk forward 2915103e947SJosef Bacik */ 2924a0cc7caSNikolay Borisov key.objectid = btrfs_ino(BTRFS_I(inode)); 293962a298fSDavid Sterba key.type = BTRFS_XATTR_ITEM_KEY; 2945103e947SJosef Bacik key.offset = 0; 2955103e947SJosef Bacik 2965103e947SJosef Bacik path = btrfs_alloc_path(); 2975103e947SJosef Bacik if (!path) 2985103e947SJosef Bacik return -ENOMEM; 299e4058b54SDavid Sterba path->reada = READA_FORWARD; 3005103e947SJosef Bacik 3015103e947SJosef Bacik /* search for our xattrs */ 302184b3d19SGabriel Niebler btrfs_for_each_slot(root, &key, &found_key, path, iter_ret) { 303daac7ba6SFilipe Manana struct extent_buffer *leaf; 304daac7ba6SFilipe Manana int slot; 305daac7ba6SFilipe Manana struct btrfs_dir_item *di; 306daac7ba6SFilipe Manana u32 item_size; 307daac7ba6SFilipe Manana u32 cur; 308daac7ba6SFilipe Manana 3095103e947SJosef Bacik leaf = path->nodes[0]; 3105103e947SJosef Bacik slot = path->slots[0]; 3115103e947SJosef Bacik 3125103e947SJosef Bacik /* check to make sure this item is what we want */ 3135103e947SJosef Bacik if (found_key.objectid != key.objectid) 3145103e947SJosef Bacik break; 315f1cd1f0bSFilipe Manana if (found_key.type > BTRFS_XATTR_ITEM_KEY) 3165103e947SJosef Bacik break; 317f1cd1f0bSFilipe Manana if (found_key.type < BTRFS_XATTR_ITEM_KEY) 318184b3d19SGabriel Niebler continue; 3195103e947SJosef Bacik 3205103e947SJosef Bacik di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); 3213212fa14SJosef Bacik item_size = btrfs_item_size(leaf, slot); 322daac7ba6SFilipe Manana cur = 0; 323daac7ba6SFilipe Manana while (cur < item_size) { 324daac7ba6SFilipe Manana u16 name_len = btrfs_dir_name_len(leaf, di); 325daac7ba6SFilipe Manana u16 data_len = btrfs_dir_data_len(leaf, di); 326daac7ba6SFilipe Manana u32 this_len = sizeof(*di) + name_len + data_len; 327daac7ba6SFilipe Manana unsigned long name_ptr = (unsigned long)(di + 1); 3285103e947SJosef Bacik 329eaa47d86SChristoph Hellwig total_size += name_len + 1; 330daac7ba6SFilipe Manana /* 331daac7ba6SFilipe Manana * We are just looking for how big our buffer needs to 332daac7ba6SFilipe Manana * be. 333daac7ba6SFilipe Manana */ 3345103e947SJosef Bacik if (!size) 3352e6a0035SLi Zefan goto next; 3365103e947SJosef Bacik 337eaa47d86SChristoph Hellwig if (!buffer || (name_len + 1) > size_left) { 338184b3d19SGabriel Niebler iter_ret = -ERANGE; 339184b3d19SGabriel Niebler break; 3405103e947SJosef Bacik } 3415103e947SJosef Bacik 342eaa47d86SChristoph Hellwig read_extent_buffer(leaf, buffer, name_ptr, name_len); 343eaa47d86SChristoph Hellwig buffer[name_len] = '\0'; 344eaa47d86SChristoph Hellwig 345eaa47d86SChristoph Hellwig size_left -= name_len + 1; 346eaa47d86SChristoph Hellwig buffer += name_len + 1; 3472e6a0035SLi Zefan next: 348daac7ba6SFilipe Manana cur += this_len; 349daac7ba6SFilipe Manana di = (struct btrfs_dir_item *)((char *)di + this_len); 350daac7ba6SFilipe Manana } 3515103e947SJosef Bacik } 352184b3d19SGabriel Niebler 353184b3d19SGabriel Niebler if (iter_ret < 0) 354184b3d19SGabriel Niebler ret = iter_ret; 355184b3d19SGabriel Niebler else 3565103e947SJosef Bacik ret = total_size; 3575103e947SJosef Bacik 3585103e947SJosef Bacik btrfs_free_path(path); 3595103e947SJosef Bacik 3605103e947SJosef Bacik return ret; 3615103e947SJosef Bacik } 3625103e947SJosef Bacik 3639172abbcSAndreas Gruenbacher static int btrfs_xattr_handler_get(const struct xattr_handler *handler, 364b296821aSAl Viro struct dentry *unused, struct inode *inode, 365b296821aSAl Viro const char *name, void *buffer, size_t size) 3669172abbcSAndreas Gruenbacher { 3679172abbcSAndreas Gruenbacher name = xattr_full_name(handler, name); 3687852781dSDavid Sterba return btrfs_getxattr(inode, name, buffer, size); 3699172abbcSAndreas Gruenbacher } 3709172abbcSAndreas Gruenbacher 3719172abbcSAndreas Gruenbacher static int btrfs_xattr_handler_set(const struct xattr_handler *handler, 372e65ce2a5SChristian Brauner struct user_namespace *mnt_userns, 37359301226SAl Viro struct dentry *unused, struct inode *inode, 37459301226SAl Viro const char *name, const void *buffer, 37559301226SAl Viro size_t size, int flags) 3769172abbcSAndreas Gruenbacher { 377b5111127SGoldwyn Rodrigues if (btrfs_root_readonly(BTRFS_I(inode)->root)) 378b5111127SGoldwyn Rodrigues return -EROFS; 379b5111127SGoldwyn Rodrigues 3809172abbcSAndreas Gruenbacher name = xattr_full_name(handler, name); 381e3de9b15SAnand Jain return btrfs_setxattr_trans(inode, name, buffer, size, flags); 3829172abbcSAndreas Gruenbacher } 3839172abbcSAndreas Gruenbacher 3849172abbcSAndreas Gruenbacher static int btrfs_xattr_handler_set_prop(const struct xattr_handler *handler, 385e65ce2a5SChristian Brauner struct user_namespace *mnt_userns, 38659301226SAl Viro struct dentry *unused, struct inode *inode, 3879172abbcSAndreas Gruenbacher const char *name, const void *value, 3889172abbcSAndreas Gruenbacher size_t size, int flags) 3899172abbcSAndreas Gruenbacher { 390f22125e5SAnand Jain int ret; 391b3f6a4beSAnand Jain struct btrfs_trans_handle *trans; 392b3f6a4beSAnand Jain struct btrfs_root *root = BTRFS_I(inode)->root; 393f22125e5SAnand Jain 3949172abbcSAndreas Gruenbacher name = xattr_full_name(handler, name); 3950e852ab8SChung-Chiang Cheng ret = btrfs_validate_prop(BTRFS_I(inode), name, value, size); 396f22125e5SAnand Jain if (ret) 397f22125e5SAnand Jain return ret; 398b3f6a4beSAnand Jain 3994b73c55fSFilipe Manana if (btrfs_ignore_prop(BTRFS_I(inode), name)) 4004b73c55fSFilipe Manana return 0; 4014b73c55fSFilipe Manana 402b3f6a4beSAnand Jain trans = btrfs_start_transaction(root, 2); 403b3f6a4beSAnand Jain if (IS_ERR(trans)) 404b3f6a4beSAnand Jain return PTR_ERR(trans); 405b3f6a4beSAnand Jain 406b3f6a4beSAnand Jain ret = btrfs_set_prop(trans, inode, name, value, size, flags); 407b3f6a4beSAnand Jain if (!ret) { 408b3f6a4beSAnand Jain inode_inc_iversion(inode); 409b3f6a4beSAnand Jain inode->i_ctime = current_time(inode); 4109a56fcd1SNikolay Borisov ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); 411193b4e83SFilipe Manana if (ret) 412193b4e83SFilipe Manana btrfs_abort_transaction(trans, ret); 413b3f6a4beSAnand Jain } 414b3f6a4beSAnand Jain 415b3f6a4beSAnand Jain btrfs_end_transaction(trans); 416b3f6a4beSAnand Jain 417b3f6a4beSAnand Jain return ret; 4189172abbcSAndreas Gruenbacher } 4199172abbcSAndreas Gruenbacher 4209172abbcSAndreas Gruenbacher static const struct xattr_handler btrfs_security_xattr_handler = { 4219172abbcSAndreas Gruenbacher .prefix = XATTR_SECURITY_PREFIX, 4229172abbcSAndreas Gruenbacher .get = btrfs_xattr_handler_get, 4239172abbcSAndreas Gruenbacher .set = btrfs_xattr_handler_set, 4249172abbcSAndreas Gruenbacher }; 4259172abbcSAndreas Gruenbacher 4269172abbcSAndreas Gruenbacher static const struct xattr_handler btrfs_trusted_xattr_handler = { 4279172abbcSAndreas Gruenbacher .prefix = XATTR_TRUSTED_PREFIX, 4289172abbcSAndreas Gruenbacher .get = btrfs_xattr_handler_get, 4299172abbcSAndreas Gruenbacher .set = btrfs_xattr_handler_set, 4309172abbcSAndreas Gruenbacher }; 4319172abbcSAndreas Gruenbacher 4329172abbcSAndreas Gruenbacher static const struct xattr_handler btrfs_user_xattr_handler = { 4339172abbcSAndreas Gruenbacher .prefix = XATTR_USER_PREFIX, 4349172abbcSAndreas Gruenbacher .get = btrfs_xattr_handler_get, 4359172abbcSAndreas Gruenbacher .set = btrfs_xattr_handler_set, 4369172abbcSAndreas Gruenbacher }; 4379172abbcSAndreas Gruenbacher 4389172abbcSAndreas Gruenbacher static const struct xattr_handler btrfs_btrfs_xattr_handler = { 4399172abbcSAndreas Gruenbacher .prefix = XATTR_BTRFS_PREFIX, 4409172abbcSAndreas Gruenbacher .get = btrfs_xattr_handler_get, 4419172abbcSAndreas Gruenbacher .set = btrfs_xattr_handler_set_prop, 4429172abbcSAndreas Gruenbacher }; 4439172abbcSAndreas Gruenbacher 444f01cbd3fSStephen Hemminger const struct xattr_handler *btrfs_xattr_handlers[] = { 4459172abbcSAndreas Gruenbacher &btrfs_security_xattr_handler, 4460eda294dSChris Mason #ifdef CONFIG_BTRFS_FS_POSIX_ACL 447996a710dSChristoph Hellwig &posix_acl_access_xattr_handler, 448996a710dSChristoph Hellwig &posix_acl_default_xattr_handler, 44995819c05SChristoph Hellwig #endif 4509172abbcSAndreas Gruenbacher &btrfs_trusted_xattr_handler, 4519172abbcSAndreas Gruenbacher &btrfs_user_xattr_handler, 4529172abbcSAndreas Gruenbacher &btrfs_btrfs_xattr_handler, 45395819c05SChristoph Hellwig NULL, 45495819c05SChristoph Hellwig }; 45595819c05SChristoph Hellwig 45648a3b636SEric Sandeen static int btrfs_initxattrs(struct inode *inode, 457419a6f30SAnand Jain const struct xattr *xattr_array, void *fs_private) 4589d8f13baSMimi Zohar { 459419a6f30SAnand Jain struct btrfs_trans_handle *trans = fs_private; 4609d8f13baSMimi Zohar const struct xattr *xattr; 461827aa18eSFilipe Manana unsigned int nofs_flag; 4629d8f13baSMimi Zohar char *name; 4639d8f13baSMimi Zohar int err = 0; 4649d8f13baSMimi Zohar 465827aa18eSFilipe Manana /* 466827aa18eSFilipe Manana * We're holding a transaction handle, so use a NOFS memory allocation 467827aa18eSFilipe Manana * context to avoid deadlock if reclaim happens. 468827aa18eSFilipe Manana */ 469827aa18eSFilipe Manana nofs_flag = memalloc_nofs_save(); 4709d8f13baSMimi Zohar for (xattr = xattr_array; xattr->name != NULL; xattr++) { 4719d8f13baSMimi Zohar name = kmalloc(XATTR_SECURITY_PREFIX_LEN + 47239a27ec1SDavid Sterba strlen(xattr->name) + 1, GFP_KERNEL); 4739d8f13baSMimi Zohar if (!name) { 4749d8f13baSMimi Zohar err = -ENOMEM; 4759d8f13baSMimi Zohar break; 4769d8f13baSMimi Zohar } 4779d8f13baSMimi Zohar strcpy(name, XATTR_SECURITY_PREFIX); 4789d8f13baSMimi Zohar strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name); 47904e6863bSAnand Jain err = btrfs_setxattr(trans, inode, name, xattr->value, 4807852781dSDavid Sterba xattr->value_len, 0); 4819d8f13baSMimi Zohar kfree(name); 4829d8f13baSMimi Zohar if (err < 0) 4839d8f13baSMimi Zohar break; 4849d8f13baSMimi Zohar } 485827aa18eSFilipe Manana memalloc_nofs_restore(nofs_flag); 4869d8f13baSMimi Zohar return err; 4879d8f13baSMimi Zohar } 4889d8f13baSMimi Zohar 489f34f57a3SYan, Zheng int btrfs_xattr_security_init(struct btrfs_trans_handle *trans, 4902a7dba39SEric Paris struct inode *inode, struct inode *dir, 4912a7dba39SEric Paris const struct qstr *qstr) 4920279b4cdSJim Owens { 4939d8f13baSMimi Zohar return security_inode_init_security(inode, dir, qstr, 4949d8f13baSMimi Zohar &btrfs_initxattrs, trans); 4950279b4cdSJim Owens } 496