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                 for ((handler) = *(handlers)++;                 \
 659                         (handler) != NULL;                      \
 660                         (handler) = *(handlers)++)
 661
 662 /*
 663  * Find the xattr_handler with the matching prefix.
 664  */
 665 static const struct xattr_handler *
 666 xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
 667 {
 668         const struct xattr_handler *handler;
 669
 670         if (!*name)
 671                 return NULL;
 672
 673         for_each_xattr_handler(handlers, handler) {
 674                 const char *n;
 675
 676                 n = strcmp_prefix(*name, xattr_prefix(handler));
 677                 if (n) {
 678                         if (!handler->prefix ^ !*n) {
 679                                 if (*n)
 680                                         continue;
 681                                 return ERR_PTR(-EINVAL);
 682                         }
 683                         *name = n;
 684                         return handler;
 685                 }
 686         }
 687         return ERR_PTR(-EOPNOTSUPP);
 688 }
 689
 690 /*
 691  * Find the handler for the prefix and dispatch its get() operation.
 692  */
 693 ssize_t
 694 generic_getxattr(struct dentry *dentry, struct inode *inode,
 695                  const char *name, void *buffer, size_t size)
 696 {
 697         const struct xattr_handler *handler;
 698
 699         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 700         if (IS_ERR(handler))
 701                 return PTR_ERR(handler);
 702         return handler->get(handler, dentry, inode,
 703                             name, buffer, size);
 704 }
 705
 706 /*
 707  * Combine the results of the list() operation from every xattr_handler in the
 708  * list.
 709  */
 710 ssize_t
 711 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 712 {
 713         const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
 714         unsigned int size = 0;
 715
 716         if (!buffer) {
 717                 for_each_xattr_handler(handlers, handler) {
 718                         if (!handler->name ||
 719                             (handler->list && !handler->list(dentry)))
 720                                 continue;
 721                         size += strlen(handler->name) + 1;
 722                 }
 723         } else {
 724                 char *buf = buffer;
 725                 size_t len;
 726
 727                 for_each_xattr_handler(handlers, handler) {
 728                         if (!handler->name ||
 729                             (handler->list && !handler->list(dentry)))
 730                                 continue;
 731                         len = strlen(handler->name);
 732                         if (len + 1 > buffer_size)
 733                                 return -ERANGE;
 734                         memcpy(buf, handler->name, len + 1);
 735                         buf += len + 1;
 736                         buffer_size -= len + 1;
 737                 }
 738                 size = buf - buffer;
 739         }
 740         return size;
 741 }
 742
 743 /*
 744  * Find the handler for the prefix and dispatch its set() operation.
 745  */
 746 int
 747 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
 748 {
 749         const struct xattr_handler *handler;
 750
 751         if (size == 0)
 752                 value = "";  /* empty EA, do not remove */
 753         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 754         if (IS_ERR(handler))
 755                 return PTR_ERR(handler);
 756         return handler->set(handler, dentry, name, value, size, flags);
 757 }
 758
 759 /*
 760  * Find the handler for the prefix and dispatch its set() operation to remove
 761  * any associated extended attribute.
 762  */
 763 int
 764 generic_removexattr(struct dentry *dentry, const char *name)
 765 {
 766         const struct xattr_handler *handler;
 767
 768         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
 769         if (IS_ERR(handler))
 770                 return PTR_ERR(handler);
 771         return handler->set(handler, dentry, name, NULL, 0, XATTR_REPLACE);
 772 }
 773
 774 EXPORT_SYMBOL(generic_getxattr);
 775 EXPORT_SYMBOL(generic_listxattr);
 776 EXPORT_SYMBOL(generic_setxattr);
 777 EXPORT_SYMBOL(generic_removexattr);
 778
 779 /**
 780  * xattr_full_name  -  Compute full attribute name from suffix
 781  *
 782  * @handler:    handler of the xattr_handler operation
 783  * @name:       name passed to the xattr_handler operation
 784  *
 785  * The get and set xattr handler operations are called with the remainder of
 786  * the attribute name after skipping the handler's prefix: for example, "foo"
 787  * is passed to the get operation of a handler with prefix "user." to get
 788  * attribute "user.foo".  The full name is still "there" in the name though.
 789  *
 790  * Note: the list xattr handler operation when called from the vfs is passed a
 791  * NULL name; some file systems use this operation internally, with varying
 792  * semantics.
 793  */
 794 const char *xattr_full_name(const struct xattr_handler *handler,
 795                             const char *name)
 796 {
 797         size_t prefix_len = strlen(xattr_prefix(handler));
 798
 799         return name - prefix_len;
 800 }
 801 EXPORT_SYMBOL(xattr_full_name);
 802
 803 /*
 804  * Allocate new xattr and copy in the value; but leave the name to callers.
 805  */
 806 struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
 807 {
 808         struct simple_xattr *new_xattr;
 809         size_t len;
 810
 811         /* wrap around? */
 812         len = sizeof(*new_xattr) + size;
 813         if (len < sizeof(*new_xattr))
 814                 return NULL;
 815
 816         new_xattr = kmalloc(len, GFP_KERNEL);
 817         if (!new_xattr)
 818                 return NULL;
 819
 820         new_xattr->size = size;
 821         memcpy(new_xattr->value, value, size);
 822         return new_xattr;
 823 }
 824
 825 /*
 826  * xattr GET operation for in-memory/pseudo filesystems
 827  */
 828 int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
 829                      void *buffer, size_t size)
 830 {
 831         struct simple_xattr *xattr;
 832         int ret = -ENODATA;
 833
 834         spin_lock(&xattrs->lock);
 835         list_for_each_entry(xattr, &xattrs->head, list) {
 836                 if (strcmp(name, xattr->name))
 837                         continue;
 838
 839                 ret = xattr->size;
 840                 if (buffer) {
 841                         if (size < xattr->size)
 842                                 ret = -ERANGE;
 843                         else
 844                                 memcpy(buffer, xattr->value, xattr->size);
 845                 }
 846                 break;
 847         }
 848         spin_unlock(&xattrs->lock);
 849         return ret;
 850 }
 851
 852 /**
 853  * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
 854  * @xattrs: target simple_xattr list
 855  * @name: name of the extended attribute
 856  * @value: value of the xattr. If %NULL, will remove the attribute.
 857  * @size: size of the new xattr
 858  * @flags: %XATTR_{CREATE|REPLACE}
 859  *
 860  * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
 861  * with -EEXIST.  If %XATTR_REPLACE is set, the xattr should exist;
 862  * otherwise, fails with -ENODATA.
 863  *
 864  * Returns 0 on success, -errno on failure.
 865  */
 866 int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
 867                      const void *value, size_t size, int flags)
 868 {
 869         struct simple_xattr *xattr;
 870         struct simple_xattr *new_xattr = NULL;
 871         int err = 0;
 872
 873         /* value == NULL means remove */
 874         if (value) {
 875                 new_xattr = simple_xattr_alloc(value, size);
 876                 if (!new_xattr)
 877                         return -ENOMEM;
 878
 879                 new_xattr->name = kstrdup(name, GFP_KERNEL);
 880                 if (!new_xattr->name) {
 881                         kfree(new_xattr);
 882                         return -ENOMEM;
 883                 }
 884         }
 885
 886         spin_lock(&xattrs->lock);
 887         list_for_each_entry(xattr, &xattrs->head, list) {
 888                 if (!strcmp(name, xattr->name)) {
 889                         if (flags & XATTR_CREATE) {
 890                                 xattr = new_xattr;
 891                                 err = -EEXIST;
 892                         } else if (new_xattr) {
 893                                 list_replace(&xattr->list, &new_xattr->list);
 894                         } else {
 895                                 list_del(&xattr->list);
 896                         }
 897                         goto out;
 898                 }
 899         }
 900         if (flags & XATTR_REPLACE) {
 901                 xattr = new_xattr;
 902                 err = -ENODATA;
 903         } else {
 904                 list_add(&new_xattr->list, &xattrs->head);
 905                 xattr = NULL;
 906         }
 907 out:
 908         spin_unlock(&xattrs->lock);
 909         if (xattr) {
 910                 kfree(xattr->name);
 911                 kfree(xattr);
 912         }
 913         return err;
 914
 915 }
 916
 917 static bool xattr_is_trusted(const char *name)
 918 {
 919         return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
 920 }
 921
 922 static int xattr_list_one(char **buffer, ssize_t *remaining_size,
 923                           const char *name)
 924 {
 925         size_t len = strlen(name) + 1;
 926         if (*buffer) {
 927                 if (*remaining_size < len)
 928                         return -ERANGE;
 929                 memcpy(*buffer, name, len);
 930                 *buffer += len;
 931         }
 932         *remaining_size -= len;
 933         return 0;
 934 }
 935
 936 /*
 937  * xattr LIST operation for in-memory/pseudo filesystems
 938  */
 939 ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
 940                           char *buffer, size_t size)
 941 {
 942         bool trusted = capable(CAP_SYS_ADMIN);
 943         struct simple_xattr *xattr;
 944         ssize_t remaining_size = size;
 945         int err = 0;
 946
 947 #ifdef CONFIG_FS_POSIX_ACL
 948         if (inode->i_acl) {
 949                 err = xattr_list_one(&buffer, &remaining_size,
 950                                      XATTR_NAME_POSIX_ACL_ACCESS);
 951                 if (err)
 952                         return err;
 953         }
 954         if (inode->i_default_acl) {
 955                 err = xattr_list_one(&buffer, &remaining_size,
 956                                      XATTR_NAME_POSIX_ACL_DEFAULT);
 957                 if (err)
 958                         return err;
 959         }
 960 #endif
 961
 962         spin_lock(&xattrs->lock);
 963         list_for_each_entry(xattr, &xattrs->head, list) {
 964                 /* skip "trusted." attributes for unprivileged callers */
 965                 if (!trusted && xattr_is_trusted(xattr->name))
 966                         continue;
 967
 968                 err = xattr_list_one(&buffer, &remaining_size, xattr->name);
 969                 if (err)
 970                         break;
 971         }
 972         spin_unlock(&xattrs->lock);
 973
 974         return err ? err : size - remaining_size;
 975 }
 976
 977 /*
 978  * Adds an extended attribute to the list
 979  */
 980 void simple_xattr_list_add(struct simple_xattrs *xattrs,
 981                            struct simple_xattr *new_xattr)
 982 {
 983         spin_lock(&xattrs->lock);
 984         list_add(&new_xattr->list, &xattrs->head);
 985         spin_unlock(&xattrs->lock);
 986 }