1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2007 Red Hat. All rights reserved.
6 #include <linux/init.h>
8 #include <linux/slab.h>
9 #include <linux/rwsem.h>
10 #include <linux/xattr.h>
11 #include <linux/security.h>
12 #include <linux/posix_acl_xattr.h>
13 #include <linux/iversion.h>
14 #include <linux/sched/mm.h>
16 #include "btrfs_inode.h"
17 #include "transaction.h"
23 int btrfs_getxattr(struct inode
*inode
, const char *name
,
24 void *buffer
, size_t size
)
26 struct btrfs_dir_item
*di
;
27 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
28 struct btrfs_path
*path
;
29 struct extent_buffer
*leaf
;
31 unsigned long data_ptr
;
33 path
= btrfs_alloc_path();
37 /* lookup the xattr by name */
38 di
= btrfs_lookup_xattr(NULL
, root
, path
, btrfs_ino(BTRFS_I(inode
)),
39 name
, strlen(name
), 0);
43 } else if (IS_ERR(di
)) {
48 leaf
= path
->nodes
[0];
49 /* if size is 0, that means we want the size of the attr */
51 ret
= btrfs_dir_data_len(leaf
, di
);
55 /* now get the data out of our dir_item */
56 if (btrfs_dir_data_len(leaf
, di
) > size
) {
62 * The way things are packed into the leaf is like this
63 * |struct btrfs_dir_item|name|data|
64 * where name is the xattr name, so security.foo, and data is the
65 * content of the xattr. data_ptr points to the location in memory
66 * where the data starts in the in memory leaf
68 data_ptr
= (unsigned long)((char *)(di
+ 1) +
69 btrfs_dir_name_len(leaf
, di
));
70 read_extent_buffer(leaf
, buffer
, data_ptr
,
71 btrfs_dir_data_len(leaf
, di
));
72 ret
= btrfs_dir_data_len(leaf
, di
);
75 btrfs_free_path(path
);
79 int btrfs_setxattr(struct btrfs_trans_handle
*trans
, struct inode
*inode
,
80 const char *name
, const void *value
, size_t size
, int flags
)
82 struct btrfs_dir_item
*di
= NULL
;
83 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
84 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
85 struct btrfs_path
*path
;
86 size_t name_len
= strlen(name
);
91 if (name_len
+ size
> BTRFS_MAX_XATTR_SIZE(root
->fs_info
))
94 path
= btrfs_alloc_path();
97 path
->skip_release_on_error
= 1;
100 di
= btrfs_lookup_xattr(trans
, root
, path
,
101 btrfs_ino(BTRFS_I(inode
)), name
, name_len
, -1);
102 if (!di
&& (flags
& XATTR_REPLACE
))
107 ret
= btrfs_delete_one_dir_name(trans
, root
, path
, di
);
112 * For a replace we can't just do the insert blindly.
113 * Do a lookup first (read-only btrfs_search_slot), and return if xattr
114 * doesn't exist. If it exists, fall down below to the insert/replace
115 * path - we can't race with a concurrent xattr delete, because the VFS
116 * locks the inode's i_mutex before calling setxattr or removexattr.
118 if (flags
& XATTR_REPLACE
) {
119 ASSERT(inode_is_locked(inode
));
120 di
= btrfs_lookup_xattr(NULL
, root
, path
,
121 btrfs_ino(BTRFS_I(inode
)), name
, name_len
, 0);
128 btrfs_release_path(path
);
132 ret
= btrfs_insert_xattr_item(trans
, root
, path
, btrfs_ino(BTRFS_I(inode
)),
133 name
, name_len
, value
, size
);
134 if (ret
== -EOVERFLOW
) {
136 * We have an existing item in a leaf, split_leaf couldn't
137 * expand it. That item might have or not a dir_item that
138 * matches our target xattr, so lets check.
141 btrfs_assert_tree_locked(path
->nodes
[0]);
142 di
= btrfs_match_dir_item_name(fs_info
, path
, name
, name_len
);
143 if (!di
&& !(flags
& XATTR_REPLACE
)) {
147 } else if (ret
== -EEXIST
) {
149 di
= btrfs_match_dir_item_name(fs_info
, path
, name
, name_len
);
150 ASSERT(di
); /* logic error */
155 if (di
&& (flags
& XATTR_CREATE
)) {
162 * We're doing a replace, and it must be atomic, that is, at
163 * any point in time we have either the old or the new xattr
164 * value in the tree. We don't want readers (getxattr and
165 * listxattrs) to miss a value, this is specially important
168 const int slot
= path
->slots
[0];
169 struct extent_buffer
*leaf
= path
->nodes
[0];
170 const u16 old_data_len
= btrfs_dir_data_len(leaf
, di
);
171 const u32 item_size
= btrfs_item_size_nr(leaf
, slot
);
172 const u32 data_size
= sizeof(*di
) + name_len
+ size
;
173 struct btrfs_item
*item
;
174 unsigned long data_ptr
;
177 if (size
> old_data_len
) {
178 if (btrfs_leaf_free_space(leaf
) <
179 (size
- old_data_len
)) {
185 if (old_data_len
+ name_len
+ sizeof(*di
) == item_size
) {
186 /* No other xattrs packed in the same leaf item. */
187 if (size
> old_data_len
)
188 btrfs_extend_item(fs_info
, path
,
189 size
- old_data_len
);
190 else if (size
< old_data_len
)
191 btrfs_truncate_item(fs_info
, path
,
194 /* There are other xattrs packed in the same item. */
195 ret
= btrfs_delete_one_dir_name(trans
, root
, path
, di
);
198 btrfs_extend_item(fs_info
, path
, data_size
);
201 item
= btrfs_item_nr(slot
);
202 ptr
= btrfs_item_ptr(leaf
, slot
, char);
203 ptr
+= btrfs_item_size(leaf
, item
) - data_size
;
204 di
= (struct btrfs_dir_item
*)ptr
;
205 btrfs_set_dir_data_len(leaf
, di
, size
);
206 data_ptr
= ((unsigned long)(di
+ 1)) + name_len
;
207 write_extent_buffer(leaf
, value
, data_ptr
, size
);
208 btrfs_mark_buffer_dirty(leaf
);
211 * Insert, and we had space for the xattr, so path->slots[0] is
212 * where our xattr dir_item is and btrfs_insert_xattr_item()
217 btrfs_free_path(path
);
222 * @value: "" makes the attribute to empty, NULL removes it
224 int btrfs_setxattr_trans(struct btrfs_trans_handle
*trans
,
225 struct inode
*inode
, const char *name
,
226 const void *value
, size_t size
, int flags
)
228 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
232 return btrfs_setxattr(trans
, inode
, name
, value
, size
, flags
);
234 trans
= btrfs_start_transaction(root
, 2);
236 return PTR_ERR(trans
);
238 ret
= btrfs_setxattr(trans
, inode
, name
, value
, size
, flags
);
242 inode_inc_iversion(inode
);
243 inode
->i_ctime
= current_time(inode
);
244 set_bit(BTRFS_INODE_COPY_EVERYTHING
, &BTRFS_I(inode
)->runtime_flags
);
245 ret
= btrfs_update_inode(trans
, root
, inode
);
248 btrfs_end_transaction(trans
);
252 ssize_t
btrfs_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
254 struct btrfs_key key
;
255 struct inode
*inode
= d_inode(dentry
);
256 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
257 struct btrfs_path
*path
;
259 size_t total_size
= 0, size_left
= size
;
262 * ok we want all objects associated with this id.
263 * NOTE: we set key.offset = 0; because we want to start with the
264 * first xattr that we find and walk forward
266 key
.objectid
= btrfs_ino(BTRFS_I(inode
));
267 key
.type
= BTRFS_XATTR_ITEM_KEY
;
270 path
= btrfs_alloc_path();
273 path
->reada
= READA_FORWARD
;
275 /* search for our xattrs */
276 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
281 struct extent_buffer
*leaf
;
283 struct btrfs_dir_item
*di
;
284 struct btrfs_key found_key
;
288 leaf
= path
->nodes
[0];
289 slot
= path
->slots
[0];
291 /* this is where we start walking through the path */
292 if (slot
>= btrfs_header_nritems(leaf
)) {
294 * if we've reached the last slot in this leaf we need
295 * to go to the next leaf and reset everything
297 ret
= btrfs_next_leaf(root
, path
);
305 btrfs_item_key_to_cpu(leaf
, &found_key
, slot
);
307 /* check to make sure this item is what we want */
308 if (found_key
.objectid
!= key
.objectid
)
310 if (found_key
.type
> BTRFS_XATTR_ITEM_KEY
)
312 if (found_key
.type
< BTRFS_XATTR_ITEM_KEY
)
315 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
316 item_size
= btrfs_item_size_nr(leaf
, slot
);
318 while (cur
< item_size
) {
319 u16 name_len
= btrfs_dir_name_len(leaf
, di
);
320 u16 data_len
= btrfs_dir_data_len(leaf
, di
);
321 u32 this_len
= sizeof(*di
) + name_len
+ data_len
;
322 unsigned long name_ptr
= (unsigned long)(di
+ 1);
324 total_size
+= name_len
+ 1;
326 * We are just looking for how big our buffer needs to
332 if (!buffer
|| (name_len
+ 1) > size_left
) {
337 read_extent_buffer(leaf
, buffer
, name_ptr
, name_len
);
338 buffer
[name_len
] = '\0';
340 size_left
-= name_len
+ 1;
341 buffer
+= name_len
+ 1;
344 di
= (struct btrfs_dir_item
*)((char *)di
+ this_len
);
352 btrfs_free_path(path
);
357 static int btrfs_xattr_handler_get(const struct xattr_handler
*handler
,
358 struct dentry
*unused
, struct inode
*inode
,
359 const char *name
, void *buffer
, size_t size
)
361 name
= xattr_full_name(handler
, name
);
362 return btrfs_getxattr(inode
, name
, buffer
, size
);
365 static int btrfs_xattr_handler_set(const struct xattr_handler
*handler
,
366 struct dentry
*unused
, struct inode
*inode
,
367 const char *name
, const void *buffer
,
368 size_t size
, int flags
)
370 name
= xattr_full_name(handler
, name
);
371 return btrfs_setxattr_trans(NULL
, inode
, name
, buffer
, size
, flags
);
374 static int btrfs_xattr_handler_set_prop(const struct xattr_handler
*handler
,
375 struct dentry
*unused
, struct inode
*inode
,
376 const char *name
, const void *value
,
377 size_t size
, int flags
)
379 name
= xattr_full_name(handler
, name
);
380 return btrfs_set_prop_trans(inode
, name
, value
, size
, flags
);
383 static const struct xattr_handler btrfs_security_xattr_handler
= {
384 .prefix
= XATTR_SECURITY_PREFIX
,
385 .get
= btrfs_xattr_handler_get
,
386 .set
= btrfs_xattr_handler_set
,
389 static const struct xattr_handler btrfs_trusted_xattr_handler
= {
390 .prefix
= XATTR_TRUSTED_PREFIX
,
391 .get
= btrfs_xattr_handler_get
,
392 .set
= btrfs_xattr_handler_set
,
395 static const struct xattr_handler btrfs_user_xattr_handler
= {
396 .prefix
= XATTR_USER_PREFIX
,
397 .get
= btrfs_xattr_handler_get
,
398 .set
= btrfs_xattr_handler_set
,
401 static const struct xattr_handler btrfs_btrfs_xattr_handler
= {
402 .prefix
= XATTR_BTRFS_PREFIX
,
403 .get
= btrfs_xattr_handler_get
,
404 .set
= btrfs_xattr_handler_set_prop
,
407 const struct xattr_handler
*btrfs_xattr_handlers
[] = {
408 &btrfs_security_xattr_handler
,
409 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
410 &posix_acl_access_xattr_handler
,
411 &posix_acl_default_xattr_handler
,
413 &btrfs_trusted_xattr_handler
,
414 &btrfs_user_xattr_handler
,
415 &btrfs_btrfs_xattr_handler
,
419 static int btrfs_initxattrs(struct inode
*inode
,
420 const struct xattr
*xattr_array
, void *fs_private
)
422 struct btrfs_trans_handle
*trans
= fs_private
;
423 const struct xattr
*xattr
;
424 unsigned int nofs_flag
;
429 * We're holding a transaction handle, so use a NOFS memory allocation
430 * context to avoid deadlock if reclaim happens.
432 nofs_flag
= memalloc_nofs_save();
433 for (xattr
= xattr_array
; xattr
->name
!= NULL
; xattr
++) {
434 name
= kmalloc(XATTR_SECURITY_PREFIX_LEN
+
435 strlen(xattr
->name
) + 1, GFP_KERNEL
);
440 strcpy(name
, XATTR_SECURITY_PREFIX
);
441 strcpy(name
+ XATTR_SECURITY_PREFIX_LEN
, xattr
->name
);
442 err
= btrfs_setxattr(trans
, inode
, name
, xattr
->value
,
443 xattr
->value_len
, 0);
448 memalloc_nofs_restore(nofs_flag
);
452 int btrfs_xattr_security_init(struct btrfs_trans_handle
*trans
,
453 struct inode
*inode
, struct inode
*dir
,
454 const struct qstr
*qstr
)
456 return security_inode_init_security(inode
, dir
, qstr
,
457 &btrfs_initxattrs
, trans
);