~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/btrfs/xattr.c

Version: ~ [ linux-5.5-rc6 ] ~ [ linux-5.4.11 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.95 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.164 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.209 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.209 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (C) 2007 Red Hat.  All rights reserved.
  4  */
  5 
  6 #include <linux/init.h>
  7 #include <linux/fs.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>
 15 #include "ctree.h"
 16 #include "btrfs_inode.h"
 17 #include "transaction.h"
 18 #include "xattr.h"
 19 #include "disk-io.h"
 20 #include "props.h"
 21 #include "locking.h"
 22 
 23 int btrfs_getxattr(struct inode *inode, const char *name,
 24                                 void *buffer, size_t size)
 25 {
 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;
 30         int ret = 0;
 31         unsigned long data_ptr;
 32 
 33         path = btrfs_alloc_path();
 34         if (!path)
 35                 return -ENOMEM;
 36 
 37         /* lookup the xattr by name */
 38         di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(BTRFS_I(inode)),
 39                         name, strlen(name), 0);
 40         if (!di) {
 41                 ret = -ENODATA;
 42                 goto out;
 43         } else if (IS_ERR(di)) {
 44                 ret = PTR_ERR(di);
 45                 goto out;
 46         }
 47 
 48         leaf = path->nodes[0];
 49         /* if size is 0, that means we want the size of the attr */
 50         if (!size) {
 51                 ret = btrfs_dir_data_len(leaf, di);
 52                 goto out;
 53         }
 54 
 55         /* now get the data out of our dir_item */
 56         if (btrfs_dir_data_len(leaf, di) > size) {
 57                 ret = -ERANGE;
 58                 goto out;
 59         }
 60 
 61         /*
 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
 67          */
 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);
 73 
 74 out:
 75         btrfs_free_path(path);
 76         return ret;
 77 }
 78 
 79 static int do_setxattr(struct btrfs_trans_handle *trans,
 80                        struct inode *inode, const char *name,
 81                        const void *value, size_t size, int flags)
 82 {
 83         struct btrfs_dir_item *di = NULL;
 84         struct btrfs_root *root = BTRFS_I(inode)->root;
 85         struct btrfs_fs_info *fs_info = root->fs_info;
 86         struct btrfs_path *path;
 87         size_t name_len = strlen(name);
 88         int ret = 0;
 89 
 90         if (name_len + size > BTRFS_MAX_XATTR_SIZE(root->fs_info))
 91                 return -ENOSPC;
 92 
 93         path = btrfs_alloc_path();
 94         if (!path)
 95                 return -ENOMEM;
 96         path->skip_release_on_error = 1;
 97 
 98         if (!value) {
 99                 di = btrfs_lookup_xattr(trans, root, path,
100                                 btrfs_ino(BTRFS_I(inode)), name, name_len, -1);
101                 if (!di && (flags & XATTR_REPLACE))
102                         ret = -ENODATA;
103                 else if (IS_ERR(di))
104                         ret = PTR_ERR(di);
105                 else if (di)
106                         ret = btrfs_delete_one_dir_name(trans, root, path, di);
107                 goto out;
108         }
109 
110         /*
111          * For a replace we can't just do the insert blindly.
112          * Do a lookup first (read-only btrfs_search_slot), and return if xattr
113          * doesn't exist. If it exists, fall down below to the insert/replace
114          * path - we can't race with a concurrent xattr delete, because the VFS
115          * locks the inode's i_mutex before calling setxattr or removexattr.
116          */
117         if (flags & XATTR_REPLACE) {
118                 ASSERT(inode_is_locked(inode));
119                 di = btrfs_lookup_xattr(NULL, root, path,
120                                 btrfs_ino(BTRFS_I(inode)), name, name_len, 0);
121                 if (!di)
122                         ret = -ENODATA;
123                 else if (IS_ERR(di))
124                         ret = PTR_ERR(di);
125                 if (ret)
126                         goto out;
127                 btrfs_release_path(path);
128                 di = NULL;
129         }
130 
131         ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(BTRFS_I(inode)),
132                                       name, name_len, value, size);
133         if (ret == -EOVERFLOW) {
134                 /*
135                  * We have an existing item in a leaf, split_leaf couldn't
136                  * expand it. That item might have or not a dir_item that
137                  * matches our target xattr, so lets check.
138                  */
139                 ret = 0;
140                 btrfs_assert_tree_locked(path->nodes[0]);
141                 di = btrfs_match_dir_item_name(fs_info, path, name, name_len);
142                 if (!di && !(flags & XATTR_REPLACE)) {
143                         ret = -ENOSPC;
144                         goto out;
145                 }
146         } else if (ret == -EEXIST) {
147                 ret = 0;
148                 di = btrfs_match_dir_item_name(fs_info, path, name, name_len);
149                 ASSERT(di); /* logic error */
150         } else if (ret) {
151                 goto out;
152         }
153 
154         if (di && (flags & XATTR_CREATE)) {
155                 ret = -EEXIST;
156                 goto out;
157         }
158 
159         if (di) {
160                 /*
161                  * We're doing a replace, and it must be atomic, that is, at
162                  * any point in time we have either the old or the new xattr
163                  * value in the tree. We don't want readers (getxattr and
164                  * listxattrs) to miss a value, this is specially important
165                  * for ACLs.
166                  */
167                 const int slot = path->slots[0];
168                 struct extent_buffer *leaf = path->nodes[0];
169                 const u16 old_data_len = btrfs_dir_data_len(leaf, di);
170                 const u32 item_size = btrfs_item_size_nr(leaf, slot);
171                 const u32 data_size = sizeof(*di) + name_len + size;
172                 struct btrfs_item *item;
173                 unsigned long data_ptr;
174                 char *ptr;
175 
176                 if (size > old_data_len) {
177                         if (btrfs_leaf_free_space(fs_info, leaf) <
178                             (size - old_data_len)) {
179                                 ret = -ENOSPC;
180                                 goto out;
181                         }
182                 }
183 
184                 if (old_data_len + name_len + sizeof(*di) == item_size) {
185                         /* No other xattrs packed in the same leaf item. */
186                         if (size > old_data_len)
187                                 btrfs_extend_item(fs_info, path,
188                                                   size - old_data_len);
189                         else if (size < old_data_len)
190                                 btrfs_truncate_item(fs_info, path,
191                                                     data_size, 1);
192                 } else {
193                         /* There are other xattrs packed in the same item. */
194                         ret = btrfs_delete_one_dir_name(trans, root, path, di);
195                         if (ret)
196                                 goto out;
197                         btrfs_extend_item(fs_info, path, data_size);
198                 }
199 
200                 item = btrfs_item_nr(slot);
201                 ptr = btrfs_item_ptr(leaf, slot, char);
202                 ptr += btrfs_item_size(leaf, item) - data_size;
203                 di = (struct btrfs_dir_item *)ptr;
204                 btrfs_set_dir_data_len(leaf, di, size);
205                 data_ptr = ((unsigned long)(di + 1)) + name_len;
206                 write_extent_buffer(leaf, value, data_ptr, size);
207                 btrfs_mark_buffer_dirty(leaf);
208         } else {
209                 /*
210                  * Insert, and we had space for the xattr, so path->slots[0] is
211                  * where our xattr dir_item is and btrfs_insert_xattr_item()
212                  * filled it.
213                  */
214         }
215 out:
216         btrfs_free_path(path);
217         return ret;
218 }
219 
220 /*
221  * @value: "" makes the attribute to empty, NULL removes it
222  */
223 int btrfs_setxattr(struct btrfs_trans_handle *trans,
224                      struct inode *inode, const char *name,
225                      const void *value, size_t size, int flags)
226 {
227         struct btrfs_root *root = BTRFS_I(inode)->root;
228         int ret;
229 
230         if (btrfs_root_readonly(root))
231                 return -EROFS;
232 
233         if (trans)
234                 return do_setxattr(trans, inode, name, value, size, flags);
235 
236         trans = btrfs_start_transaction(root, 2);
237         if (IS_ERR(trans))
238                 return PTR_ERR(trans);
239 
240         ret = do_setxattr(trans, inode, name, value, size, flags);
241         if (ret)
242                 goto out;
243 
244         inode_inc_iversion(inode);
245         inode->i_ctime = current_time(inode);
246         set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
247         ret = btrfs_update_inode(trans, root, inode);
248         BUG_ON(ret);
249 out:
250         btrfs_end_transaction(trans);
251         return ret;
252 }
253 
254 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
255 {
256         struct btrfs_key key;
257         struct inode *inode = d_inode(dentry);
258         struct btrfs_root *root = BTRFS_I(inode)->root;
259         struct btrfs_path *path;
260         int ret = 0;
261         size_t total_size = 0, size_left = size;
262 
263         /*
264          * ok we want all objects associated with this id.
265          * NOTE: we set key.offset = 0; because we want to start with the
266          * first xattr that we find and walk forward
267          */
268         key.objectid = btrfs_ino(BTRFS_I(inode));
269         key.type = BTRFS_XATTR_ITEM_KEY;
270         key.offset = 0;
271 
272         path = btrfs_alloc_path();
273         if (!path)
274                 return -ENOMEM;
275         path->reada = READA_FORWARD;
276 
277         /* search for our xattrs */
278         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
279         if (ret < 0)
280                 goto err;
281 
282         while (1) {
283                 struct extent_buffer *leaf;
284                 int slot;
285                 struct btrfs_dir_item *di;
286                 struct btrfs_key found_key;
287                 u32 item_size;
288                 u32 cur;
289 
290                 leaf = path->nodes[0];
291                 slot = path->slots[0];
292 
293                 /* this is where we start walking through the path */
294                 if (slot >= btrfs_header_nritems(leaf)) {
295                         /*
296                          * if we've reached the last slot in this leaf we need
297                          * to go to the next leaf and reset everything
298                          */
299                         ret = btrfs_next_leaf(root, path);
300                         if (ret < 0)
301                                 goto err;
302                         else if (ret > 0)
303                                 break;
304                         continue;
305                 }
306 
307                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
308 
309                 /* check to make sure this item is what we want */
310                 if (found_key.objectid != key.objectid)
311                         break;
312                 if (found_key.type > BTRFS_XATTR_ITEM_KEY)
313                         break;
314                 if (found_key.type < BTRFS_XATTR_ITEM_KEY)
315                         goto next_item;
316 
317                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
318                 item_size = btrfs_item_size_nr(leaf, slot);
319                 cur = 0;
320                 while (cur < item_size) {
321                         u16 name_len = btrfs_dir_name_len(leaf, di);
322                         u16 data_len = btrfs_dir_data_len(leaf, di);
323                         u32 this_len = sizeof(*di) + name_len + data_len;
324                         unsigned long name_ptr = (unsigned long)(di + 1);
325 
326                         total_size += name_len + 1;
327                         /*
328                          * We are just looking for how big our buffer needs to
329                          * be.
330                          */
331                         if (!size)
332                                 goto next;
333 
334                         if (!buffer || (name_len + 1) > size_left) {
335                                 ret = -ERANGE;
336                                 goto err;
337                         }
338 
339                         read_extent_buffer(leaf, buffer, name_ptr, name_len);
340                         buffer[name_len] = '\0';
341 
342                         size_left -= name_len + 1;
343                         buffer += name_len + 1;
344 next:
345                         cur += this_len;
346                         di = (struct btrfs_dir_item *)((char *)di + this_len);
347                 }
348 next_item:
349                 path->slots[0]++;
350         }
351         ret = total_size;
352 
353 err:
354         btrfs_free_path(path);
355 
356         return ret;
357 }
358 
359 static int btrfs_xattr_handler_get(const struct xattr_handler *handler,
360                                    struct dentry *unused, struct inode *inode,
361                                    const char *name, void *buffer, size_t size)
362 {
363         name = xattr_full_name(handler, name);
364         return btrfs_getxattr(inode, name, buffer, size);
365 }
366 
367 static int btrfs_xattr_handler_set(const struct xattr_handler *handler,
368                                    struct dentry *unused, struct inode *inode,
369                                    const char *name, const void *buffer,
370                                    size_t size, int flags)
371 {
372         name = xattr_full_name(handler, name);
373         return btrfs_setxattr(NULL, inode, name, buffer, size, flags);
374 }
375 
376 static int btrfs_xattr_handler_set_prop(const struct xattr_handler *handler,
377                                         struct dentry *unused, struct inode *inode,
378                                         const char *name, const void *value,
379                                         size_t size, int flags)
380 {
381         name = xattr_full_name(handler, name);
382         return btrfs_set_prop(inode, name, value, size, flags);
383 }
384 
385 static const struct xattr_handler btrfs_security_xattr_handler = {
386         .prefix = XATTR_SECURITY_PREFIX,
387         .get = btrfs_xattr_handler_get,
388         .set = btrfs_xattr_handler_set,
389 };
390 
391 static const struct xattr_handler btrfs_trusted_xattr_handler = {
392         .prefix = XATTR_TRUSTED_PREFIX,
393         .get = btrfs_xattr_handler_get,
394         .set = btrfs_xattr_handler_set,
395 };
396 
397 static const struct xattr_handler btrfs_user_xattr_handler = {
398         .prefix = XATTR_USER_PREFIX,
399         .get = btrfs_xattr_handler_get,
400         .set = btrfs_xattr_handler_set,
401 };
402 
403 static const struct xattr_handler btrfs_btrfs_xattr_handler = {
404         .prefix = XATTR_BTRFS_PREFIX,
405         .get = btrfs_xattr_handler_get,
406         .set = btrfs_xattr_handler_set_prop,
407 };
408 
409 const struct xattr_handler *btrfs_xattr_handlers[] = {
410         &btrfs_security_xattr_handler,
411 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
412         &posix_acl_access_xattr_handler,
413         &posix_acl_default_xattr_handler,
414 #endif
415         &btrfs_trusted_xattr_handler,
416         &btrfs_user_xattr_handler,
417         &btrfs_btrfs_xattr_handler,
418         NULL,
419 };
420 
421 static int btrfs_initxattrs(struct inode *inode,
422                             const struct xattr *xattr_array, void *fs_info)
423 {
424         const struct xattr *xattr;
425         struct btrfs_trans_handle *trans = fs_info;
426         unsigned int nofs_flag;
427         char *name;
428         int err = 0;
429 
430         /*
431          * We're holding a transaction handle, so use a NOFS memory allocation
432          * context to avoid deadlock if reclaim happens.
433          */
434         nofs_flag = memalloc_nofs_save();
435         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
436                 name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
437                                strlen(xattr->name) + 1, GFP_KERNEL);
438                 if (!name) {
439                         err = -ENOMEM;
440                         break;
441                 }
442                 strcpy(name, XATTR_SECURITY_PREFIX);
443                 strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
444                 err = btrfs_setxattr(trans, inode, name, xattr->value,
445                                 xattr->value_len, 0);
446                 kfree(name);
447                 if (err < 0)
448                         break;
449         }
450         memalloc_nofs_restore(nofs_flag);
451         return err;
452 }
453 
454 int btrfs_xattr_security_init(struct btrfs_trans_handle *trans,
455                               struct inode *inode, struct inode *dir,
456                               const struct qstr *qstr)
457 {
458         return security_inode_init_security(inode, dir, qstr,
459                                             &btrfs_initxattrs, trans);
460 }
461 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp