fs/xattr.c

   1 /*
   2   File: fs/xattr.c
   3
   4   Extended attribute handling.
   5
   6   Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
   7   Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
   8   Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
   9  */
  10 #include <linux/fs.h>
  11 #include <linux/slab.h>
  12 #include <linux/file.h>
  13 #include <linux/xattr.h>
  14 #include <linux/mount.h>
  15 #include <linux/namei.h>
  16 #include <linux/security.h>
  17 #include <linux/evm.h>
  18 #include <linux/syscalls.h>
  19 #include <linux/export.h>
  20 #include <linux/fsnotify.h>
  21 #include <linux/audit.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/posix_acl_xattr.h>
  24
  25 #include <asm/uaccess.h>
  26
  27 /*
  28  * Check permissions for extended attribute access.  This is a bit complicated
  29  * because different namespaces have very different rules.
  30  */
  31 static int
  32 xattr_permission(struct inode *inode, const char *name, int mask)
  33 {
  34         /*
  35          * We can never set or remove an extended attribute on a read-only
  36          * filesystem  or on an immutable / append-only inode.
  37          */
  38         if (mask & MAY_WRITE) {
  39                 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  40                         return -EPERM;
  41         }
  42
  43         /*
  44          * No restriction for security.* and system.* from the VFS.  Decision
  45          * on these is left to the underlying filesystem / security module.
  46          */
  47         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
  48             !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
  49                 return 0;
  50
  51         /*
  52          * The trusted.* namespace can only be accessed by privileged users.
  53          */
  54         if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
  55                 if (!capable(CAP_SYS_ADMIN))
  56                         return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
  57                 return 0;
  58         }
  59
  60         /*
  61          * In the user.* namespace, only regular files and directories can have
  62          * extended attributes. For sticky directories, only the owner and
  63          * privileged users can write attributes.
  64          */
  65         if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
  66                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
  67                         return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
  68                 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
  69                     (mask & MAY_WRITE) && !inode_owner_or_capable(inode))
  70                         return -EPERM;
  71         }
  72
  73         return inode_permission(inode, mask);
  74 }
  75
  76 /**
  77  *  __vfs_setxattr_noperm - perform setxattr operation without performing
  78  *  permission checks.
  79  *
  80  *  @dentry - object to perform setxattr on
  81  *  @name - xattr name to set
  82  *  @value - value to set @name to
  83  *  @size - size of @value
  84  *  @flags - flags to pass into filesystem operations
  85  *
  86  *  returns the result of the internal setxattr or setsecurity operations.
  87  *
  88  *  This function requires the caller to lock the inode's i_mutex before it
  89  *  is executed. It also assumes that the caller will make the appropriate
  90  *  permission checks.
  91  */
  92 int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
  93                 const void *value, size_t size, int flags)
  94 {
  95         struct inode *inode = dentry->d_inode;
  96         int error = -EOPNOTSUPP;
  97         int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
  98                                    XATTR_SECURITY_PREFIX_LEN);
  99
 100         if (issec)
 101                 inode->i_flags &= ~S_NOSEC;
 102         if (inode->i_op->setxattr) {
 103                 error = inode->i_op->setxattr(dentry, name, value, size, flags);
 104                 if (!error) {
 105                         fsnotify_xattr(dentry);
 106                         security_inode_post_setxattr(dentry, name, value,
 107                                                      size, flags);
 108                 }
 109         } else if (issec) {
 110                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
 111                 error = security_inode_setsecurity(inode, suffix, value,
 112                                                    size, flags);
 113                 if (!error)
 114                         fsnotify_xattr(dentry);
 115         }
 116
 117         return error;
 118 }
 119
 120
 121 int
 122 vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 123                 size_t size, int flags)
 124 {
 125         struct inode *inode = dentry->d_inode;
 126         int error;
 127
 128         error = xattr_permission(inode, name, MAY_WRITE);
 129         if (error)
 130                 return error;
 131
 132         inode_lock(inode);
 133         error = security_inode_setxattr(dentry, name, value, size, flags);
 134         if (error)
 135                 goto out;
 136
 137         error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
 138
 139 out:
 140         inode_unlock(inode);
 141         return error;
 142 }
 143 EXPORT_SYMBOL_GPL(vfs_setxattr);
 144
 145 ssize_t
 146 xattr_getsecurity(struct inode *inode, const char *name, void *value,
 147                         size_t size)
 148 {
 149         void *buffer = NULL;
 150         ssize_t len;
 151
 152         if (!value || !size) {
 153                 len = security_inode_getsecurity(inode, name, &buffer, false);
 154                 goto out_noalloc;
 155         }
 156
 157         len = security_inode_getsecurity(inode, name, &buffer, true);
 158         if (len < 0)
 159                 return len;
 160         if (size < len) {
 161                 len = -ERANGE;
 162                 goto out;
 163         }
 164         memcpy(value, buffer, len);
 165 out:
 166         security_release_secctx(buffer, len);
 167 out_noalloc:
 168         return len;
 169 }
 170 EXPORT_SYMBOL_GPL(xattr_getsecurity);
 171
 172 /*
 173  * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
 174  *
 175  * Allocate memory, if not already allocated, or re-allocate correct size,
 176  * before retrieving the extended attribute.
 177  *
 178  * Returns the result of alloc, if failed, or the getxattr operation.
 179  */
 180 ssize_t
 181 vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
 182                    size_t xattr_size, gfp_t flags)
 183 {
 184         struct inode *inode = dentry->d_inode;
 185         char *value = *xattr_value;
 186         int error;
 187
 188         error = xattr_permission(inode, name, MAY_READ);
 189         if (error)
 190                 return error;
 191
 192         if (!inode->i_op->getxattr)
 193                 return -EOPNOTSUPP;
 194
 195         error = inode->i_op->getxattr(dentry, inode, name, NULL, 0);
 196         if (error < 0)
 197                 return error;
 198
 199         if (!value || (error > xattr_size)) {
 200                 value = krealloc(*xattr_value, error + 1, flags);
 201                 if (!value)
 202                         return -ENOMEM;
 203                 memset(value, 0, error + 1);
 204         }
 205
 206         error = inode->i_op->getxattr(dentry, inode, name, value, error);
 207         *xattr_value = value;
 208         return error;
 209 }
 210
 211 ssize_t
 212 vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
 213 {
 214         struct inode *inode = dentry->d_inode;
 215         int error;
 216
 217         error = xattr_permission(inode, name, MAY_READ);
 218         if (error)
 219                 return error;
 220
 221         error = security_inode_getxattr(dentry, name);
 222         if (error)
 223                 return error;
 224
 225         if (!strncmp(name, XATTR_SECURITY_PREFIX,
 226                                 XATTR_SECURITY_PREFIX_LEN)) {
 227                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
 228                 int ret = xattr_getsecurity(inode, suffix, value, size);
 229                 /*
 230                  * Only overwrite the return value if a security module
 231                  * is actually active.
 232                  */
 233                 if (ret == -EOPNOTSUPP)
 234                         goto nolsm;
 235                 return ret;
 236         }
 237 nolsm:
 238         if (inode->i_op->getxattr)
 239                 error = inode->i_op->getxattr(dentry, inode, name, value, size);
 240         else
 241                 error = -EOPNOTSUPP;
 242
 243         return error;
 244 }
 245 EXPORT_SYMBOL_GPL(vfs_getxattr);
 246
 247 ssize_t
 248 vfs_listxattr(struct dentry *d, char *list, size_t size)
 249 {
 250         ssize_t error;
 251
 252         error = security_inode_listxattr(d);
 253         if (error)
 254                 return error;
 255         error = -EOPNOTSUPP;
 256         if (d->d_inode->i_op->listxattr) {
 257                 error = d->d_inode->i_op->listxattr(d, list, size);
 258         } else {
 259                 error = security_inode_listsecurity(d->d_inode, list, size);
 260                 if (size && error > size)
 261                         error = -ERANGE;
 262         }
 263         return error;
 264 }
 265 EXPORT_SYMBOL_GPL(vfs_listxattr);
 266
 267 int
 268 vfs_removexattr(struct dentry *dentry, const char *name)
 269 {
 270         struct inode *inode = dentry->d_inode;
 271         int error;
 272
 273         if (!inode->i_op->removexattr)
 274                 return -EOPNOTSUPP;
 275
 276         error = xattr_permission(inode, name, MAY_WRITE);
 277         if (error)
 278                 return error;
 279
 280         inode_lock(inode);
 281         error = security_inode_removexattr(dentry, name);
 282         if (error)
 283                 goto out;
 284
 285         error = inode->i_op->removexattr(dentry, name);
 286
 287         if (!error) {
 288                 fsnotify_xattr(dentry);
 289                 evm_inode_post_removexattr(dentry, name);
 290         }
 291
 292 out:
 293         inode_unlock(inode);
 294         return error;
 295 }
 296 EXPORT_SYMBOL_GPL(vfs_removexattr);
 297
 298
 299 /*
 300  * Extended attribute SET operations
 301  */
 302 static long
 303 setxattr(struct dentry *d, const char __user *name, const void __user *value,
 304          size_t size, int flags)
 305 {
 306         int error;
 307         void *kvalue = NULL;
 308         char kname[XATTR_NAME_MAX + 1];
 309
 310         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
 311                 return -EINVAL;
 312
 313         error = strncpy_from_user(kname, name, sizeof(kname));
 314         if (error == 0 || error == sizeof(kname))
 315                 error = -ERANGE;
 316         if (error < 0)
 317                 return error;
 318
 319         if (size) {
 320                 if (size > XATTR_SIZE_MAX)
 321                         return -E2BIG;
 322                 kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
 323                 if (!kvalue) {
 324                         kvalue = vmalloc(size);
 325                         if (!kvalue)
 326                                 return -ENOMEM;
 327                 }
 328                 if (copy_from_user(kvalue, value, size)) {
 329                         error = -EFAULT;
 330                         goto out;
 331                 }
 332                 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
 333                     (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
 334                         posix_acl_fix_xattr_from_user(kvalue, size);
 335         }
 336
 337         error = vfs_setxattr(d, kname, kvalue, size, flags);
 338 out:
 339         kvfree(kvalue);
 340
 341         return error;
 342 }
 343
 344 static int path_setxattr(const char __user *pathname,
 345                          const char __user *name, const void __user *value,
 346                          size_t size, int flags, unsigned int lookup_flags)
 347 {
 348         struct path path;
 349         int error;
 350 retry:
 351         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
 352         if (error)
 353                 return error;
 354         error = mnt_want_write(path.mnt);
 355         if (!error) {
 356                 error = setxattr(path.dentry, name, value, size, flags);
 357                 mnt_drop_write(path.mnt);
 358         }
 359         path_put(&path);
 360         if (retry_estale(error, lookup_flags)) {
 361                 lookup_flags |= LOOKUP_REVAL;
 362                 goto retry;
 363         }
 364         return error;
 365 }
 366
 367 SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
 368                 const char __user *, name, const void __user *, value,
 369                 size_t, size, int, flags)
 370 {
 371         return path_setxattr(pathname, name, value, size, flags, LOOKUP_FOLLOW);
 372 }
 373
 374 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
 375                 const char __user *, name, const void __user *, value,
 376                 size_t, size, int, flags)
 377 {
 378         return path_setxattr(pathname, name, value, size, flags, 0);
 379 }
 380
 381 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
 382                 const void __user *,value, size_t, size, int, flags)
 383 {
 384         struct fd f = fdget(fd);
 385         int error = -EBADF;
 386
 387         if (!f.file)
 388                 return error;
 389         audit_file(f.file);
 390         error = mnt_want_write_file(f.file);
 391         if (!error) {
 392                 error = setxattr(f.file->f_path.dentry, name, value, size, flags);
 393                 mnt_drop_write_file(f.file);
 394         }
 395         fdput(f);
 396         return error;
 397 }
 398
 399 /*
 400  * Extended attribute GET operations
 401  */
 402 static ssize_t
 403 getxattr(struct dentry *d, const char __user *name, void __user *value,
 404          size_t size)
 405 {
 406         ssize_t error;
 407         void *kvalue = NULL;
 408         char kname[XATTR_NAME_MAX + 1];
 409
 410         error = strncpy_from_user(kname, name, sizeof(kname));
 411         if (error == 0 || error == sizeof(kname))
 412                 error = -ERANGE;
 413         if (error < 0)
 414                 return error;
 415
 416         if (size) {
 417                 if (size > XATTR_SIZE_MAX)
 418                         size = XATTR_SIZE_MAX;
 419                 kvalue = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
 420                 if (!kvalue) {
 421                         kvalue = vmalloc(size);
 422                         if (!kvalue)
 423                                 return -ENOMEM;
 424                 }
 425         }
 426
 427         error = vfs_getxattr(d, kname, kvalue, size);
 428         if (error > 0) {
 429                 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
 430                     (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
 431                         posix_acl_fix_xattr_to_user(kvalue, size);
 432                 if (size && copy_to_user(value, kvalue, error))
 433                         error = -EFAULT;
 434         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
 435                 /* The file system tried to returned a value bigger
 436                    than XATTR_SIZE_MAX bytes. Not possible. */
 437                 error = -E2BIG;
 438         }
 439
 440         kvfree(kvalue);
 441
 442         return error;
 443 }
 444
 445 static ssize_t path_getxattr(const char __user *pathname,
 446                              const char __user *name, void __user *value,
 447                              size_t size, unsigned int lookup_flags)
 448 {
 449         struct path path;
 450         ssize_t error;
 451 retry:
 452         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
 453         if (error)
 454                 return error;
 455         error = getxattr(path.dentry, name, value, size);
 456         path_put(&path);
 457         if (retry_estale(error, lookup_flags)) {
 458                 lookup_flags |= LOOKUP_REVAL;
 459                 goto retry;
 460         }
 461         return error;
 462 }
 463
 464 SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
 465                 const char __user *, name, void __user *, value, size_t, size)
 466 {
 467         return path_getxattr(pathname, name, value, size, LOOKUP_FOLLOW);
 468 }
 469
 470 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
 471                 const char __user *, name, void __user *, value, size_t, size)
 472 {
 473         return path_getxattr(pathname, name, value, size, 0);
 474 }
 475
 476 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
 477                 void __user *, value, size_t, size)
 478 {
 479         struct fd f = fdget(fd);
 480         ssize_t error = -EBADF;
 481
 482         if (!f.file)
 483                 return error;
 484         audit_file(f.file);
 485         error = getxattr(f.file->f_path.dentry, name, value, size);
 486         fdput(f);
 487         return error;
 488 }
 489
 490 /*
 491  * Extended attribute LIST operations
 492  */
 493 static ssize_t
 494 listxattr(struct dentry *d, char __user *list, size_t size)
 495 {
 496         ssize_t error;
 497         char *klist = NULL;
 498
 499         if (size) {
 500                 if (size > XATTR_LIST_MAX)
 501                         size = XATTR_LIST_MAX;
 502                 klist = kmalloc(size, __GFP_NOWARN | GFP_KERNEL);
 503                 if (!klist) {
 504                         klist = vmalloc(size);
 505                         if (!klist)
 506                                 return -ENOMEM;
 507                 }
 508         }
 509
 510         error = vfs_listxattr(d, klist, size);
 511         if (error > 0) {
 512                 if (size && copy_to_user(list, klist, error))
 513                         error = -EFAULT;
 514         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
 515                 /* The file system tried to returned a list bigger
 516                    than XATTR_LIST_MAX bytes. Not possible. */
 517                 error = -E2BIG;
 518         }
 519
 520         kvfree(klist);
 521
 522         return error;
 523 }
 524
 525 static ssize_t path_listxattr(const char __user *pathname, char __user *list,
 526                               size_t size, unsigned int lookup_flags)
 527 {
 528         struct path path;
 529         ssize_t error;
 530 retry:
 531         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
 532         if (error)
 533                 return error;
 534         error = listxattr(path.dentry, list, size);
 535         path_put(&path);
 536         if (retry_estale(error, lookup_flags)) {
 537                 lookup_flags |= LOOKUP_REVAL;
 538                 goto retry;
 539         }
 540         return error;
 541 }
 542
 543 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
 544                 size_t, size)
 545 {
 546         return path_listxattr(pathname, list, size, LOOKUP_FOLLOW);
 547 }
 548
 549 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
 550                 size_t, size)
 551 {
 552         return path_listxattr(pathname, list, size, 0);
 553 }
 554
 555 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
 556 {
 557         struct fd f = fdget(fd);
 558         ssize_t error = -EBADF;
 559
 560         if (!f.file)
 561                 return error;
 562         audit_file(f.file);
 563         error = listxattr(f.file->f_path.dentry, list, size);
 564         fdput(f);
 565         return error;
 566 }
 567
 568 /*
 569  * Extended attribute REMOVE operations
 570  */
 571 static long
 572 removexattr(struct dentry *d, const char __user *name)
 573 {
 574         int error;
 575         char kname[XATTR_NAME_MAX + 1];
 576
 577         error = strncpy_from_user(kname, name, sizeof(kname));
 578         if (error == 0 || error == sizeof(kname))
 579                 error = -ERANGE;
 580         if (error < 0)
 581                 return error;
 582
 583         return vfs_removexattr(d, kname);
 584 }
 585
 586 static int path_removexattr(const char __user *pathname,
 587                             const char __user *name, unsigned int lookup_flags)
 588 {
 589         struct path path;
 590         int error;
 591 retry:
 592         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
 593         if (error)
 594                 return error;
 595         error = mnt_want_write(path.mnt);
 596         if (!error) {
 597                 error = removexattr(path.dentry, name);
 598                 mnt_drop_write(path.mnt);
 599         }
 600         path_put(&path);
 601         if (retry_estale(error, lookup_flags)) {
 602                 lookup_flags |= LOOKUP_REVAL;
 603                 goto retry;
 604         }
 605         return error;
 606 }
 607
 608 SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
 609                 const char __user *, name)
 610 {
 611         return path_removexattr(pathname, name, LOOKUP_FOLLOW);
 612 }
 613
 614 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
 615                 const char __user *, name)
 616 {
 617         return path_removexattr(pathname, name, 0);
 618 }
 619
 620 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
 621 {
 622         struct fd f = fdget(fd);
 623         int error = -EBADF;
 624
 625         if (!f.file)
 626                 return error;
 627         audit_file(f.file);
 628         error = mnt_want_write_file(f.file);
 629         if (!error) {
 630                 error = removexattr(f.file->f_path.dentry, name);
 631                 mnt_drop_write_file(f.file);
 632         }
 633         fdput(f);
 634         return error;
 635 }
 636
 637
 638 static const char *
 639 strcmp_prefix(const char *a, const char *a_prefix)
 640 {
 641         while (*a_prefix && *a == *a_prefix) {
 642                 a++;
 643                 a_prefix++;
 644         }
 645         return *a_prefix ? NULL : a;
 646 }
 647
 648 /*
 649  * In order to implement different sets of xattr operations for each xattr
 650  * prefix with the generic xattr API, a filesystem should create a
 651  * null-terminated array of struct xattr_handler (one for each prefix) and
 652  * hang a pointer to it off of the s_xattr field of the superblock.
 653  *
 654  * The generic_fooxattr() functions will use this list to dispatch xattr
 655  * operations to the correct xattr_handler.
 656  */
 657 #define for_each_xattr_handler(handlers, handler)               \
 658         if (handlers)                                           \
 659                 for ((handler) = *(handlers)++;                 \
 660                         (handler) != NULL;                      \
 661                         (handler) = *(handlers)++)
 662
 663 /*
 664  * Find the xattr_handler with the matching prefix.
 665  */
 666 static const struct xattr_handler *
 667 xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
 668 {
 669         const struct xattr_handler *handler;
 670
 671         if (!*name)
 672                 return ERR_PTR(-EINVAL);
 673
 674         for_each_xattr_handler(handlers, handler) {
 675                 const char *n;
 676
 677                 n = strcmp_prefix(*name, xattr_prefix(handler));
 678                 if (n) {
 679                         if (!handler->prefix ^ !*n) {
 680                                 if (*n)
 681                                         continue;
 682                                 return ERR_PTR(-EINVAL);
 683                         }
 684                         *name = n;
 685                         return handler;
 686                 }
 687         }
 688         return ERR_PTR(-EOPNOTSUPP);
 689 }
 690
 691 /*
 692  * Find the handler for the prefix and dispatch its get() operation.
 693  */
 694 ssize_t
 695 generic_getxattr(struct dentry *dentry, struct inode *inode,
 696                  const char *name, void *buffer, size_t size)
 697 {
 698         const struct xattr_handler *handler;
 699
 700         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 701         if (IS_ERR(handler))
 702                 return PTR_ERR(handler);
 703         return handler->get(handler, dentry, inode,
 704                             name, buffer, size);
 705 }
 706
 707 /*
 708  * Combine the results of the list() operation from every xattr_handler in the
 709  * list.
 710  */
 711 ssize_t
 712 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 713 {
 714         const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
 715         unsigned int size = 0;
 716
 717         if (!buffer) {
 718                 for_each_xattr_handler(handlers, handler) {
 719                         if (!handler->name ||
 720                             (handler->list && !handler->list(dentry)))
 721                                 continue;
 722                         size += strlen(handler->name) + 1;
 723                 }
 724         } else {
 725                 char *buf = buffer;
 726                 size_t len;
 727
 728                 for_each_xattr_handler(handlers, handler) {
 729                         if (!handler->name ||
 730                             (handler->list && !handler->list(dentry)))
 731                                 continue;
 732                         len = strlen(handler->name);
 733                         if (len + 1 > buffer_size)
 734                                 return -ERANGE;
 735                         memcpy(buf, handler->name, len + 1);
 736                         buf += len + 1;
 737                         buffer_size -= len + 1;
 738                 }
 739                 size = buf - buffer;
 740         }
 741         return size;
 742 }
 743
 744 /*
 745  * Find the handler for the prefix and dispatch its set() operation.
 746  */
 747 int
 748 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
 749 {
 750         const struct xattr_handler *handler;
 751
 752         if (size == 0)
 753                 value = "";  /* empty EA, do not remove */
 754         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 755         if (IS_ERR(handler))
 756                 return PTR_ERR(handler);
 757         return handler->set(handler, dentry, name, value, size, flags);
 758 }
 759
 760 /*
 761  * Find the handler for the prefix and dispatch its set() operation to remove
 762  * any associated extended attribute.
 763  */
 764 int
 765 generic_removexattr(struct dentry *dentry, const char *name)
 766 {
 767         const struct xattr_handler *handler;
 768
 769         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 770         if (IS_ERR(handler))
 771                 return PTR_ERR(handler);
 772         return handler->set(handler, dentry, name, NULL, 0, XATTR_REPLACE);
 773 }
 774
 775 EXPORT_SYMBOL(generic_getxattr);
 776 EXPORT_SYMBOL(generic_listxattr);
 777 EXPORT_SYMBOL(generic_setxattr);
 778 EXPORT_SYMBOL(generic_removexattr);
 779
 780 /**
 781  * xattr_full_name  -  Compute full attribute name from suffix
 782  *
 783  * @handler:    handler of the xattr_handler operation
 784  * @name:       name passed to the xattr_handler operation
 785  *
 786  * The get and set xattr handler operations are called with the remainder of
 787  * the attribute name after skipping the handler's prefix: for example, "foo"
 788  * is passed to the get operation of a handler with prefix "user." to get
 789  * attribute "user.foo".  The full name is still "there" in the name though.
 790  *
 791  * Note: the list xattr handler operation when called from the vfs is passed a
 792  * NULL name; some file systems use this operation internally, with varying
 793  * semantics.
 794  */
 795 const char *xattr_full_name(const struct xattr_handler *handler,
 796                             const char *name)
 797 {
 798         size_t prefix_len = strlen(xattr_prefix(handler));
 799
 800         return name - prefix_len;
 801 }
 802 EXPORT_SYMBOL(xattr_full_name);
 803
 804 /*
 805  * Allocate new xattr and copy in the value; but leave the name to callers.
 806  */
 807 struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
 808 {
 809         struct simple_xattr *new_xattr;
 810         size_t len;
 811
 812         /* wrap around? */
 813         len = sizeof(*new_xattr) + size;
 814         if (len < sizeof(*new_xattr))
 815                 return NULL;
 816
 817         new_xattr = kmalloc(len, GFP_KERNEL);
 818         if (!new_xattr)
 819                 return NULL;
 820
 821         new_xattr->size = size;
 822         memcpy(new_xattr->value, value, size);
 823         return new_xattr;
 824 }
 825
 826 /*
 827  * xattr GET operation for in-memory/pseudo filesystems
 828  */
 829 int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
 830                      void *buffer, size_t size)
 831 {
 832         struct simple_xattr *xattr;
 833         int ret = -ENODATA;
 834
 835         spin_lock(&xattrs->lock);
 836         list_for_each_entry(xattr, &xattrs->head, list) {
 837                 if (strcmp(name, xattr->name))
 838                         continue;
 839
 840                 ret = xattr->size;
 841                 if (buffer) {
 842                         if (size < xattr->size)
 843                                 ret = -ERANGE;
 844                         else
 845                                 memcpy(buffer, xattr->value, xattr->size);
 846                 }
 847                 break;
 848         }
 849         spin_unlock(&xattrs->lock);
 850         return ret;
 851 }
 852
 853 /**
 854  * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
 855  * @xattrs: target simple_xattr list
 856  * @name: name of the extended attribute
 857  * @value: value of the xattr. If %NULL, will remove the attribute.
 858  * @size: size of the new xattr
 859  * @flags: %XATTR_{CREATE|REPLACE}
 860  *
 861  * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
 862  * with -EEXIST.  If %XATTR_REPLACE is set, the xattr should exist;
 863  * otherwise, fails with -ENODATA.
 864  *
 865  * Returns 0 on success, -errno on failure.
 866  */
 867 int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
 868                      const void *value, size_t size, int flags)
 869 {
 870         struct simple_xattr *xattr;
 871         struct simple_xattr *new_xattr = NULL;
 872         int err = 0;
 873
 874         /* value == NULL means remove */
 875         if (value) {
 876                 new_xattr = simple_xattr_alloc(value, size);
 877                 if (!new_xattr)
 878                         return -ENOMEM;
 879
 880                 new_xattr->name = kstrdup(name, GFP_KERNEL);
 881                 if (!new_xattr->name) {
 882                         kfree(new_xattr);
 883                         return -ENOMEM;
 884                 }
 885         }
 886
 887         spin_lock(&xattrs->lock);
 888         list_for_each_entry(xattr, &xattrs->head, list) {
 889                 if (!strcmp(name, xattr->name)) {
 890                         if (flags & XATTR_CREATE) {
 891                                 xattr = new_xattr;
 892                                 err = -EEXIST;
 893                         } else if (new_xattr) {
 894                                 list_replace(&xattr->list, &new_xattr->list);
 895                         } else {
 896                                 list_del(&xattr->list);
 897                         }
 898                         goto out;
 899                 }
 900         }
 901         if (flags & XATTR_REPLACE) {
 902                 xattr = new_xattr;
 903                 err = -ENODATA;
 904         } else {
 905                 list_add(&new_xattr->list, &xattrs->head);
 906                 xattr = NULL;
 907         }
 908 out:
 909         spin_unlock(&xattrs->lock);
 910         if (xattr) {
 911                 kfree(xattr->name);
 912                 kfree(xattr);
 913         }
 914         return err;
 915
 916 }
 917
 918 static bool xattr_is_trusted(const char *name)
 919 {
 920         return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
 921 }
 922
 923 static int xattr_list_one(char **buffer, ssize_t *remaining_size,
 924                           const char *name)
 925 {
 926         size_t len = strlen(name) + 1;
 927         if (*buffer) {
 928                 if (*remaining_size < len)
 929                         return -ERANGE;
 930                 memcpy(*buffer, name, len);
 931                 *buffer += len;
 932         }
 933         *remaining_size -= len;
 934         return 0;
 935 }
 936
 937 /*
 938  * xattr LIST operation for in-memory/pseudo filesystems
 939  */
 940 ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
 941                           char *buffer, size_t size)
 942 {
 943         bool trusted = capable(CAP_SYS_ADMIN);
 944         struct simple_xattr *xattr;
 945         ssize_t remaining_size = size;
 946         int err = 0;
 947
 948 #ifdef CONFIG_FS_POSIX_ACL
 949         if (inode->i_acl) {
 950                 err = xattr_list_one(&buffer, &remaining_size,
 951                                      XATTR_NAME_POSIX_ACL_ACCESS);
 952                 if (err)
 953                         return err;
 954         }
 955         if (inode->i_default_acl) {
 956                 err = xattr_list_one(&buffer, &remaining_size,
 957                                      XATTR_NAME_POSIX_ACL_DEFAULT);
 958                 if (err)
 959                         return err;
 960         }
 961 #endif
 962
 963         spin_lock(&xattrs->lock);
 964         list_for_each_entry(xattr, &xattrs->head, list) {
 965                 /* skip "trusted." attributes for unprivileged callers */
 966                 if (!trusted && xattr_is_trusted(xattr->name))
 967                         continue;
 968
 969                 err = xattr_list_one(&buffer, &remaining_size, xattr->name);
 970                 if (err)
 971                         break;
 972         }
 973         spin_unlock(&xattrs->lock);
 974
 975         return err ? err : size - remaining_size;
 976 }
 977
 978 /*
 979  * Adds an extended attribute to the list
 980  */
 981 void simple_xattr_list_add(struct simple_xattrs *xattrs,
 982                            struct simple_xattr *new_xattr)
 983 {
 984         spin_lock(&xattrs->lock);
 985         list_add(&new_xattr->list, &xattrs->head);
 986         spin_unlock(&xattrs->lock);
 987 }