fs/btrfs/xattr.c

   1 /*
   2  * Copyright (C) 2007 Red Hat.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <linux/init.h>
  20 #include <linux/fs.h>
  21 #include <linux/slab.h>
  22 #include <linux/rwsem.h>
  23 #include <linux/xattr.h>
  24 #include "ctree.h"
  25 #include "btrfs_inode.h"
  26 #include "transaction.h"
  27 #include "xattr.h"
  28 #include "disk-io.h"
  29
  30 static struct xattr_handler *btrfs_xattr_handler_map[] = {
  31         [BTRFS_XATTR_INDEX_USER]                = &btrfs_xattr_user_handler,
  32         [BTRFS_XATTR_INDEX_POSIX_ACL_ACCESS]    = &btrfs_xattr_acl_access_handler,
  33         [BTRFS_XATTR_INDEX_POSIX_ACL_DEFAULT]   = &btrfs_xattr_acl_default_handler,
  34         [BTRFS_XATTR_INDEX_TRUSTED]             = &btrfs_xattr_trusted_handler,
  35         [BTRFS_XATTR_INDEX_SECURITY]            = &btrfs_xattr_security_handler,
  36         [BTRFS_XATTR_INDEX_SYSTEM]              = &btrfs_xattr_system_handler,
  37 };
  38
  39 struct xattr_handler *btrfs_xattr_handlers[] = {
  40         &btrfs_xattr_user_handler,
  41         &btrfs_xattr_acl_access_handler,
  42         &btrfs_xattr_acl_default_handler,
  43         &btrfs_xattr_trusted_handler,
  44         &btrfs_xattr_security_handler,
  45         &btrfs_xattr_system_handler,
  46         NULL,
  47 };
  48
  49 /*
  50  * @param name - the xattr name
  51  * @return - the xattr_handler for the xattr, NULL if its not found
  52  *
  53  * use this with listxattr where we don't already know the type of xattr we
  54  * have
  55  */
  56 static struct xattr_handler *find_btrfs_xattr_handler(struct extent_buffer *l,
  57                                                       unsigned long name_ptr,
  58                                                       u16 name_len)
  59 {
  60         struct xattr_handler *handler = NULL;
  61         int i = 0;
  62
  63         for (handler = btrfs_xattr_handlers[i]; handler != NULL; i++,
  64              handler = btrfs_xattr_handlers[i]) {
  65                 u16 prefix_len = strlen(handler->prefix);
  66
  67                 if (name_len < prefix_len)
  68                         continue;
  69
  70                 if (memcmp_extent_buffer(l, handler->prefix, name_ptr,
  71                                          prefix_len) == 0)
  72                         break;
  73         }
  74
  75         return handler;
  76 }
  77
  78 /*
  79  * @param name_index - the index for the xattr handler
  80  * @return the xattr_handler if we found it, NULL otherwise
  81  *
  82  * use this if we know the type of the xattr already
  83  */
  84 static struct xattr_handler *btrfs_xattr_handler(int name_index)
  85 {
  86         struct xattr_handler *handler = NULL;
  87
  88         if (name_index >= 0 &&
  89             name_index < ARRAY_SIZE(btrfs_xattr_handler_map))
  90                 handler = btrfs_xattr_handler_map[name_index];
  91
  92         return handler;
  93 }
  94
  95 static inline char *get_name(const char *name, int name_index)
  96 {
  97         char *ret = NULL;
  98         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
  99         int prefix_len;
 100
 101         if (!handler)
 102                 return ret;
 103
 104         prefix_len = strlen(handler->prefix);
 105
 106         ret = kmalloc(strlen(name) + prefix_len + 1, GFP_KERNEL);
 107         if (!ret)
 108                 return ret;
 109
 110         memcpy(ret, handler->prefix, prefix_len);
 111         memcpy(ret+prefix_len, name, strlen(name));
 112         ret[prefix_len + strlen(name)] = '\0';
 113
 114         return ret;
 115 }
 116
 117 size_t btrfs_xattr_generic_list(struct inode *inode, char *list,
 118                                 size_t list_size, const char *name,
 119                                 size_t name_len)
 120 {
 121         if (list && (name_len+1) <= list_size) {
 122                 memcpy(list, name, name_len);
 123                 list[name_len] = '\0';
 124         } else
 125                 return -ERANGE;
 126
 127         return name_len+1;
 128 }
 129
 130 ssize_t btrfs_xattr_get(struct inode *inode, int name_index,
 131                         const char *attr_name, void *buffer, size_t size)
 132 {
 133         struct btrfs_dir_item *di;
 134         struct btrfs_root *root = BTRFS_I(inode)->root;
 135         struct btrfs_path *path;
 136         struct extent_buffer *leaf;
 137         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
 138         int ret = 0;
 139         unsigned long data_ptr;
 140         char *name;
 141
 142         if (!handler)
 143                 return -EOPNOTSUPP;
 144
 145         /* just in case... */
 146         if (*attr_name == '\0')
 147                 return -EINVAL;
 148
 149         name = get_name(attr_name, name_index);
 150         if (!name)
 151                 return -ENOMEM;
 152
 153         path = btrfs_alloc_path();
 154         if (!path) {
 155                 kfree(name);
 156                 return -ENOMEM;
 157         }
 158
 159         mutex_lock(&root->fs_info->fs_mutex);
 160         /* lookup the xattr by name */
 161         di = btrfs_lookup_xattr(NULL, root, path, inode->i_ino, name,
 162                                 strlen(name), 0);
 163         if (!di || IS_ERR(di)) {
 164                 ret = -ENODATA;
 165                 goto out;
 166         }
 167
 168         leaf = path->nodes[0];
 169         /* if size is 0, that means we want the size of the attr */
 170         if (!size) {
 171                 ret = btrfs_dir_data_len(leaf, di);
 172                 goto out;
 173         }
 174
 175         /* now get the data out of our dir_item */
 176         if (btrfs_dir_data_len(leaf, di) > size) {
 177                 ret = -ERANGE;
 178                 goto out;
 179         }
 180         data_ptr = (unsigned long)((char *)(di + 1) +
 181                                    btrfs_dir_name_len(leaf, di));
 182         read_extent_buffer(leaf, buffer, data_ptr,
 183                            btrfs_dir_name_len(leaf, di));
 184         ret = btrfs_dir_data_len(leaf, di);
 185
 186 out:
 187         mutex_unlock(&root->fs_info->fs_mutex);
 188         kfree(name);
 189         btrfs_free_path(path);
 190         return ret;
 191 }
 192
 193 int btrfs_xattr_set(struct inode *inode, int name_index,
 194                     const char *attr_name, const void *value, size_t size,
 195                     int flags)
 196 {
 197         struct btrfs_dir_item *di;
 198         struct btrfs_root *root = BTRFS_I(inode)->root;
 199         struct btrfs_trans_handle *trans;
 200         struct btrfs_path *path;
 201         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
 202         char *name;
 203         int ret = 0, mod = 0;
 204
 205         if (!handler)
 206                 return -EOPNOTSUPP;
 207
 208         /* just in case... */
 209         if (*attr_name == '\0')
 210                 return -EINVAL;
 211
 212         name = get_name(attr_name, name_index);
 213         if (!name)
 214                 return -ENOMEM;
 215
 216         path = btrfs_alloc_path();
 217         if (!path) {
 218                 kfree(name);
 219                 return -ENOMEM;
 220         }
 221
 222         mutex_lock(&root->fs_info->fs_mutex);
 223         trans = btrfs_start_transaction(root, 1);
 224         btrfs_set_trans_block_group(trans, inode);
 225
 226         /* first lets see if we already have this xattr */
 227         di = btrfs_lookup_xattr(trans, root, path, inode->i_ino, name,
 228                                 strlen(name), -1);
 229         if (IS_ERR(di)) {
 230                 ret = PTR_ERR(di);
 231                 goto out;
 232         }
 233
 234         /* ok we already have this xattr, lets remove it */
 235         if (di) {
 236                 /* if we want create only exit */
 237                 if (flags & XATTR_CREATE) {
 238                         ret = -EEXIST;
 239                         goto out;
 240                 }
 241
 242                 ret = btrfs_delete_one_dir_name(trans, root, path, di);
 243                 if (ret)
 244                         goto out;
 245                 btrfs_release_path(root, path);
 246
 247                 /* if we don't have a value then we are removing the xattr */
 248                 if (!value) {
 249                         mod = 1;
 250                         goto out;
 251                 }
 252         } else if (flags & XATTR_REPLACE) {
 253                 /* we couldn't find the attr to replace, so error out */
 254                 ret = -ENODATA;
 255                 goto out;
 256         }
 257
 258         /* ok we have to create a completely new xattr */
 259         ret = btrfs_insert_xattr_item(trans, root, name, strlen(name),
 260                                       value, size, inode->i_ino);
 261         if (ret)
 262                 goto out;
 263         mod = 1;
 264
 265 out:
 266         if (mod) {
 267                 inode->i_ctime = CURRENT_TIME;
 268                 ret = btrfs_update_inode(trans, root, inode);
 269         }
 270
 271         btrfs_end_transaction(trans, root);
 272         mutex_unlock(&root->fs_info->fs_mutex);
 273         kfree(name);
 274         btrfs_free_path(path);
 275
 276         return ret;
 277 }
 278
 279 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 280 {
 281         struct btrfs_key key, found_key;
 282         struct inode *inode = dentry->d_inode;
 283         struct btrfs_root *root = BTRFS_I(inode)->root;
 284         struct btrfs_path *path;
 285         struct btrfs_item *item;
 286         struct extent_buffer *leaf;
 287         struct btrfs_dir_item *di;
 288         struct xattr_handler *handler;
 289         int ret = 0, slot, advance;
 290         size_t total_size = 0, size_left = size, written;
 291         unsigned long name_ptr;
 292         char *name;
 293         u32 nritems;
 294
 295         /*
 296          * ok we want all objects associated with this id.
 297          * NOTE: we set key.offset = 0; because we want to start with the
 298          * first xattr that we find and walk forward
 299          */
 300         key.objectid = inode->i_ino;
 301         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
 302         key.offset = 0;
 303
 304         path = btrfs_alloc_path();
 305         if (!path)
 306                 return -ENOMEM;
 307         path->reada = 2;
 308
 309         mutex_lock(&root->fs_info->fs_mutex);
 310
 311         /* search for our xattrs */
 312         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 313         if (ret < 0)
 314                 goto err;
 315         ret = 0;
 316         advance = 0;
 317         while (1) {
 318                 leaf = path->nodes[0];
 319                 nritems = btrfs_header_nritems(leaf);
 320                 slot = path->slots[0];
 321
 322                 /* this is where we start walking through the path */
 323                 if (advance || slot >= nritems) {
 324                         /*
 325                          * if we've reached the last slot in this leaf we need
 326                          * to go to the next leaf and reset everything
 327                          */
 328                         if (slot >= nritems-1) {
 329                                 ret = btrfs_next_leaf(root, path);
 330                                 if (ret)
 331                                         break;
 332                                 leaf = path->nodes[0];
 333                                 nritems = btrfs_header_nritems(leaf);
 334                                 slot = path->slots[0];
 335                         } else {
 336                                 /*
 337                                  * just walking through the slots on this leaf
 338                                  */
 339                                 slot++;
 340                                 path->slots[0]++;
 341                         }
 342                 }
 343                 advance = 1;
 344
 345                 item = btrfs_item_nr(leaf, slot);
 346                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
 347
 348                 /* check to make sure this item is what we want */
 349                 if (found_key.objectid != key.objectid)
 350                         break;
 351                 if (btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY)
 352                         break;
 353
 354                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
 355
 356                 total_size += btrfs_dir_name_len(leaf, di)+1;
 357
 358                 /* we are just looking for how big our buffer needs to be */
 359                 if (!size)
 360                         continue;
 361
 362                 /* find our handler for this xattr */
 363                 name_ptr = (unsigned long)(di + 1);
 364                 handler = find_btrfs_xattr_handler(leaf, name_ptr,
 365                                                    btrfs_dir_name_len(leaf, di));
 366                 if (!handler) {
 367                         printk(KERN_ERR "btrfs: unsupported xattr found\n");
 368                         continue;
 369                 }
 370
 371                 name = kmalloc(btrfs_dir_name_len(leaf, di), GFP_KERNEL);
 372                 read_extent_buffer(leaf, name, name_ptr,
 373                                    btrfs_dir_name_len(leaf, di));
 374
 375                 /* call the list function associated with this xattr */
 376                 written = handler->list(inode, buffer, size_left, name,
 377                                         btrfs_dir_name_len(leaf, di));
 378                 kfree(name);
 379
 380                 if (written < 0) {
 381                         ret = -ERANGE;
 382                         break;
 383                 }
 384
 385                 size_left -= written;
 386                 buffer += written;
 387         }
 388         ret = total_size;
 389
 390 err:
 391         mutex_unlock(&root->fs_info->fs_mutex);
 392         btrfs_free_path(path);
 393
 394         return ret;
 395 }
 396
 397 /*
 398  * delete all the xattrs associated with the inode.  fs_mutex should be
 399  * held when we come into here
 400  */
 401 int btrfs_delete_xattrs(struct btrfs_trans_handle *trans,
 402                         struct btrfs_root *root, struct inode *inode)
 403 {
 404         struct btrfs_path *path;
 405         struct btrfs_key key, found_key;
 406         struct btrfs_item *item;
 407         struct extent_buffer *leaf;
 408         int ret;
 409
 410         path = btrfs_alloc_path();
 411         if (!path)
 412                 return -ENOMEM;
 413         path->reada = -1;
 414         key.objectid = inode->i_ino;
 415         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
 416         key.offset = (u64)-1;
 417
 418         while(1) {
 419                 /* look for our next xattr */
 420                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 421                 if (ret < 0)
 422                         goto out;
 423                 BUG_ON(ret == 0);
 424
 425                 if (path->slots[0] == 0)
 426                         break;
 427
 428                 path->slots[0]--;
 429                 leaf = path->nodes[0];
 430                 item = btrfs_item_nr(leaf, path->slots[0]);
 431                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 432
 433                 if (found_key.objectid != key.objectid)
 434                         break;
 435                 if (btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY)
 436                         break;
 437
 438                 ret = btrfs_del_item(trans, root, path);
 439                 BUG_ON(ret);
 440                 btrfs_release_path(root, path);
 441         }
 442         ret = 0;
 443 out:
 444         btrfs_free_path(path);
 445
 446         return ret;
 447 }
 448
 449 /*
 450  * Handler functions
 451  */
 452 #define BTRFS_XATTR_SETGET_FUNCS(name, index)                           \
 453 static int btrfs_xattr_##name##_get(struct inode *inode,                \
 454                                     const char *name, void *value,      \
 455                                     size_t size)                        \
 456 {                                                                       \
 457         return btrfs_xattr_get(inode, index, name, value, size);        \
 458 }                                                                       \
 459 static int btrfs_xattr_##name##_set(struct inode *inode,                \
 460                                     const char *name, const void *value,\
 461                                     size_t size, int flags)             \
 462 {                                                                       \
 463         return btrfs_xattr_set(inode, index, name, value, size, flags); \
 464 }                                                                       \
 465
 466 BTRFS_XATTR_SETGET_FUNCS(security, BTRFS_XATTR_INDEX_SECURITY);
 467 BTRFS_XATTR_SETGET_FUNCS(system, BTRFS_XATTR_INDEX_SYSTEM);
 468 BTRFS_XATTR_SETGET_FUNCS(user, BTRFS_XATTR_INDEX_USER);
 469 BTRFS_XATTR_SETGET_FUNCS(trusted, BTRFS_XATTR_INDEX_TRUSTED);
 470
 471 struct xattr_handler btrfs_xattr_security_handler = {
 472         .prefix = XATTR_SECURITY_PREFIX,
 473         .list   = btrfs_xattr_generic_list,
 474         .get    = btrfs_xattr_security_get,
 475         .set    = btrfs_xattr_security_set,
 476 };
 477
 478 struct xattr_handler btrfs_xattr_system_handler = {
 479         .prefix = XATTR_SYSTEM_PREFIX,
 480         .list   = btrfs_xattr_generic_list,
 481         .get    = btrfs_xattr_system_get,
 482         .set    = btrfs_xattr_system_set,
 483 };
 484
 485 struct xattr_handler btrfs_xattr_user_handler = {
 486         .prefix = XATTR_USER_PREFIX,
 487         .list   = btrfs_xattr_generic_list,
 488         .get    = btrfs_xattr_user_get,
 489         .set    = btrfs_xattr_user_set,
 490 };
 491
 492 struct xattr_handler btrfs_xattr_trusted_handler = {
 493         .prefix = XATTR_USER_PREFIX,
 494         .list   = btrfs_xattr_generic_list,
 495         .get    = btrfs_xattr_trusted_get,
 496         .set    = btrfs_xattr_trusted_set,
 497 };