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 mutex_lock(&inode->i_mutex); 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 mutex_unlock(&inode->i_mutex); 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, 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, name, value, error); 207 *xattr_value = value; 208 return error; 209 } 210 211 /* Compare an extended attribute value with the given value */ 212 int vfs_xattr_cmp(struct dentry *dentry, const char *xattr_name, 213 const char *value, size_t size, gfp_t flags) 214 { 215 char *xattr_value = NULL; 216 int rc; 217 218 rc = vfs_getxattr_alloc(dentry, xattr_name, &xattr_value, 0, flags); 219 if (rc < 0) 220 return rc; 221 222 if ((rc != size) || (memcmp(xattr_value, value, rc) != 0)) 223 rc = -EINVAL; 224 else 225 rc = 0; 226 kfree(xattr_value); 227 return rc; 228 } 229 230 ssize_t 231 vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size) 232 { 233 struct inode *inode = dentry->d_inode; 234 int error; 235 236 error = xattr_permission(inode, name, MAY_READ); 237 if (error) 238 return error; 239 240 error = security_inode_getxattr(dentry, name); 241 if (error) 242 return error; 243 244 if (!strncmp(name, XATTR_SECURITY_PREFIX, 245 XATTR_SECURITY_PREFIX_LEN)) { 246 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN; 247 int ret = xattr_getsecurity(inode, suffix, value, size); 248 /* 249 * Only overwrite the return value if a security module 250 * is actually active. 251 */ 252 if (ret == -EOPNOTSUPP) 253 goto nolsm; 254 return ret; 255 } 256 nolsm: 257 if (inode->i_op->getxattr) 258 error = inode->i_op->getxattr(dentry, name, value, size); 259 else 260 error = -EOPNOTSUPP; 261 262 return error; 263 } 264 EXPORT_SYMBOL_GPL(vfs_getxattr); 265 266 ssize_t 267 vfs_listxattr(struct dentry *d, char *list, size_t size) 268 { 269 ssize_t error; 270 271 error = security_inode_listxattr(d); 272 if (error) 273 return error; 274 error = -EOPNOTSUPP; 275 if (d->d_inode->i_op->listxattr) { 276 error = d->d_inode->i_op->listxattr(d, list, size); 277 } else { 278 error = security_inode_listsecurity(d->d_inode, list, size); 279 if (size && error > size) 280 error = -ERANGE; 281 } 282 return error; 283 } 284 EXPORT_SYMBOL_GPL(vfs_listxattr); 285 286 int 287 vfs_removexattr(struct dentry *dentry, const char *name) 288 { 289 struct inode *inode = dentry->d_inode; 290 int error; 291 292 if (!inode->i_op->removexattr) 293 return -EOPNOTSUPP; 294 295 error = xattr_permission(inode, name, MAY_WRITE); 296 if (error) 297 return error; 298 299 mutex_lock(&inode->i_mutex); 300 error = security_inode_removexattr(dentry, name); 301 if (error) { 302 mutex_unlock(&inode->i_mutex); 303 return error; 304 } 305 306 error = inode->i_op->removexattr(dentry, name); 307 mutex_unlock(&inode->i_mutex); 308 309 if (!error) { 310 fsnotify_xattr(dentry); 311 evm_inode_post_removexattr(dentry, name); 312 } 313 return error; 314 } 315 EXPORT_SYMBOL_GPL(vfs_removexattr); 316 317 318 /* 319 * Extended attribute SET operations 320 */ 321 static long 322 setxattr(struct dentry *d, const char __user *name, const void __user *value, 323 size_t size, int flags) 324 { 325 int error; 326 void *kvalue = NULL; 327 void *vvalue = NULL; /* If non-NULL, we used vmalloc() */ 328 char kname[XATTR_NAME_MAX + 1]; 329 330 if (flags & ~(XATTR_CREATE|XATTR_REPLACE)) 331 return -EINVAL; 332 333 error = strncpy_from_user(kname, name, sizeof(kname)); 334 if (error == 0 || error == sizeof(kname)) 335 error = -ERANGE; 336 if (error < 0) 337 return error; 338 339 if (size) { 340 if (size > XATTR_SIZE_MAX) 341 return -E2BIG; 342 kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN); 343 if (!kvalue) { 344 vvalue = vmalloc(size); 345 if (!vvalue) 346 return -ENOMEM; 347 kvalue = vvalue; 348 } 349 if (copy_from_user(kvalue, value, size)) { 350 error = -EFAULT; 351 goto out; 352 } 353 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) || 354 (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0)) 355 posix_acl_fix_xattr_from_user(kvalue, size); 356 } 357 358 error = vfs_setxattr(d, kname, kvalue, size, flags); 359 out: 360 if (vvalue) 361 vfree(vvalue); 362 else 363 kfree(kvalue); 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 struct path path; 372 int error; 373 374 error = user_path(pathname, &path); 375 if (error) 376 return error; 377 error = mnt_want_write(path.mnt); 378 if (!error) { 379 error = setxattr(path.dentry, name, value, size, flags); 380 mnt_drop_write(path.mnt); 381 } 382 path_put(&path); 383 return error; 384 } 385 386 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname, 387 const char __user *, name, const void __user *, value, 388 size_t, size, int, flags) 389 { 390 struct path path; 391 int error; 392 393 error = user_lpath(pathname, &path); 394 if (error) 395 return error; 396 error = mnt_want_write(path.mnt); 397 if (!error) { 398 error = setxattr(path.dentry, name, value, size, flags); 399 mnt_drop_write(path.mnt); 400 } 401 path_put(&path); 402 return error; 403 } 404 405 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name, 406 const void __user *,value, size_t, size, int, flags) 407 { 408 struct fd f = fdget(fd); 409 struct dentry *dentry; 410 int error = -EBADF; 411 412 if (!f.file) 413 return error; 414 dentry = f.file->f_path.dentry; 415 audit_inode(NULL, dentry); 416 error = mnt_want_write_file(f.file); 417 if (!error) { 418 error = setxattr(dentry, name, value, size, flags); 419 mnt_drop_write_file(f.file); 420 } 421 fdput(f); 422 return error; 423 } 424 425 /* 426 * Extended attribute GET operations 427 */ 428 static ssize_t 429 getxattr(struct dentry *d, const char __user *name, void __user *value, 430 size_t size) 431 { 432 ssize_t error; 433 void *kvalue = NULL; 434 void *vvalue = NULL; 435 char kname[XATTR_NAME_MAX + 1]; 436 437 error = strncpy_from_user(kname, name, sizeof(kname)); 438 if (error == 0 || error == sizeof(kname)) 439 error = -ERANGE; 440 if (error < 0) 441 return error; 442 443 if (size) { 444 if (size > XATTR_SIZE_MAX) 445 size = XATTR_SIZE_MAX; 446 kvalue = kzalloc(size, GFP_KERNEL | __GFP_NOWARN); 447 if (!kvalue) { 448 vvalue = vmalloc(size); 449 if (!vvalue) 450 return -ENOMEM; 451 kvalue = vvalue; 452 } 453 } 454 455 error = vfs_getxattr(d, kname, kvalue, size); 456 if (error > 0) { 457 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) || 458 (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0)) 459 posix_acl_fix_xattr_to_user(kvalue, size); 460 if (size && copy_to_user(value, kvalue, error)) 461 error = -EFAULT; 462 } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) { 463 /* The file system tried to returned a value bigger 464 than XATTR_SIZE_MAX bytes. Not possible. */ 465 error = -E2BIG; 466 } 467 if (vvalue) 468 vfree(vvalue); 469 else 470 kfree(kvalue); 471 return error; 472 } 473 474 SYSCALL_DEFINE4(getxattr, const char __user *, pathname, 475 const char __user *, name, void __user *, value, size_t, size) 476 { 477 struct path path; 478 ssize_t error; 479 480 error = user_path(pathname, &path); 481 if (error) 482 return error; 483 error = getxattr(path.dentry, name, value, size); 484 path_put(&path); 485 return error; 486 } 487 488 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname, 489 const char __user *, name, void __user *, value, size_t, size) 490 { 491 struct path path; 492 ssize_t error; 493 494 error = user_lpath(pathname, &path); 495 if (error) 496 return error; 497 error = getxattr(path.dentry, name, value, size); 498 path_put(&path); 499 return error; 500 } 501 502 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name, 503 void __user *, value, size_t, size) 504 { 505 struct fd f = fdget(fd); 506 ssize_t error = -EBADF; 507 508 if (!f.file) 509 return error; 510 audit_inode(NULL, f.file->f_path.dentry); 511 error = getxattr(f.file->f_path.dentry, name, value, size); 512 fdput(f); 513 return error; 514 } 515 516 /* 517 * Extended attribute LIST operations 518 */ 519 static ssize_t 520 listxattr(struct dentry *d, char __user *list, size_t size) 521 { 522 ssize_t error; 523 char *klist = NULL; 524 char *vlist = NULL; /* If non-NULL, we used vmalloc() */ 525 526 if (size) { 527 if (size > XATTR_LIST_MAX) 528 size = XATTR_LIST_MAX; 529 klist = kmalloc(size, __GFP_NOWARN | GFP_KERNEL); 530 if (!klist) { 531 vlist = vmalloc(size); 532 if (!vlist) 533 return -ENOMEM; 534 klist = vlist; 535 } 536 } 537 538 error = vfs_listxattr(d, klist, size); 539 if (error > 0) { 540 if (size && copy_to_user(list, klist, error)) 541 error = -EFAULT; 542 } else if (error == -ERANGE && size >= XATTR_LIST_MAX) { 543 /* The file system tried to returned a list bigger 544 than XATTR_LIST_MAX bytes. Not possible. */ 545 error = -E2BIG; 546 } 547 if (vlist) 548 vfree(vlist); 549 else 550 kfree(klist); 551 return error; 552 } 553 554 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list, 555 size_t, size) 556 { 557 struct path path; 558 ssize_t error; 559 560 error = user_path(pathname, &path); 561 if (error) 562 return error; 563 error = listxattr(path.dentry, list, size); 564 path_put(&path); 565 return error; 566 } 567 568 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list, 569 size_t, size) 570 { 571 struct path path; 572 ssize_t error; 573 574 error = user_lpath(pathname, &path); 575 if (error) 576 return error; 577 error = listxattr(path.dentry, list, size); 578 path_put(&path); 579 return error; 580 } 581 582 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size) 583 { 584 struct fd f = fdget(fd); 585 ssize_t error = -EBADF; 586 587 if (!f.file) 588 return error; 589 audit_inode(NULL, f.file->f_path.dentry); 590 error = listxattr(f.file->f_path.dentry, list, size); 591 fdput(f); 592 return error; 593 } 594 595 /* 596 * Extended attribute REMOVE operations 597 */ 598 static long 599 removexattr(struct dentry *d, const char __user *name) 600 { 601 int error; 602 char kname[XATTR_NAME_MAX + 1]; 603 604 error = strncpy_from_user(kname, name, sizeof(kname)); 605 if (error == 0 || error == sizeof(kname)) 606 error = -ERANGE; 607 if (error < 0) 608 return error; 609 610 return vfs_removexattr(d, kname); 611 } 612 613 SYSCALL_DEFINE2(removexattr, const char __user *, pathname, 614 const char __user *, name) 615 { 616 struct path path; 617 int error; 618 619 error = user_path(pathname, &path); 620 if (error) 621 return error; 622 error = mnt_want_write(path.mnt); 623 if (!error) { 624 error = removexattr(path.dentry, name); 625 mnt_drop_write(path.mnt); 626 } 627 path_put(&path); 628 return error; 629 } 630 631 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname, 632 const char __user *, name) 633 { 634 struct path path; 635 int error; 636 637 error = user_lpath(pathname, &path); 638 if (error) 639 return error; 640 error = mnt_want_write(path.mnt); 641 if (!error) { 642 error = removexattr(path.dentry, name); 643 mnt_drop_write(path.mnt); 644 } 645 path_put(&path); 646 return error; 647 } 648 649 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name) 650 { 651 struct fd f = fdget(fd); 652 struct dentry *dentry; 653 int error = -EBADF; 654 655 if (!f.file) 656 return error; 657 dentry = f.file->f_path.dentry; 658 audit_inode(NULL, dentry); 659 error = mnt_want_write_file(f.file); 660 if (!error) { 661 error = removexattr(dentry, name); 662 mnt_drop_write_file(f.file); 663 } 664 fdput(f); 665 return error; 666 } 667 668 669 static const char * 670 strcmp_prefix(const char *a, const char *a_prefix) 671 { 672 while (*a_prefix && *a == *a_prefix) { 673 a++; 674 a_prefix++; 675 } 676 return *a_prefix ? NULL : a; 677 } 678 679 /* 680 * In order to implement different sets of xattr operations for each xattr 681 * prefix with the generic xattr API, a filesystem should create a 682 * null-terminated array of struct xattr_handler (one for each prefix) and 683 * hang a pointer to it off of the s_xattr field of the superblock. 684 * 685 * The generic_fooxattr() functions will use this list to dispatch xattr 686 * operations to the correct xattr_handler. 687 */ 688 #define for_each_xattr_handler(handlers, handler) \ 689 for ((handler) = *(handlers)++; \ 690 (handler) != NULL; \ 691 (handler) = *(handlers)++) 692 693 /* 694 * Find the xattr_handler with the matching prefix. 695 */ 696 static const struct xattr_handler * 697 xattr_resolve_name(const struct xattr_handler **handlers, const char **name) 698 { 699 const struct xattr_handler *handler; 700 701 if (!*name) 702 return NULL; 703 704 for_each_xattr_handler(handlers, handler) { 705 const char *n = strcmp_prefix(*name, handler->prefix); 706 if (n) { 707 *name = n; 708 break; 709 } 710 } 711 return handler; 712 } 713 714 /* 715 * Find the handler for the prefix and dispatch its get() operation. 716 */ 717 ssize_t 718 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size) 719 { 720 const struct xattr_handler *handler; 721 722 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name); 723 if (!handler) 724 return -EOPNOTSUPP; 725 return handler->get(dentry, name, buffer, size, handler->flags); 726 } 727 728 /* 729 * Combine the results of the list() operation from every xattr_handler in the 730 * list. 731 */ 732 ssize_t 733 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size) 734 { 735 const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr; 736 unsigned int size = 0; 737 738 if (!buffer) { 739 for_each_xattr_handler(handlers, handler) { 740 size += handler->list(dentry, NULL, 0, NULL, 0, 741 handler->flags); 742 } 743 } else { 744 char *buf = buffer; 745 746 for_each_xattr_handler(handlers, handler) { 747 size = handler->list(dentry, buf, buffer_size, 748 NULL, 0, handler->flags); 749 if (size > buffer_size) 750 return -ERANGE; 751 buf += size; 752 buffer_size -= size; 753 } 754 size = buf - buffer; 755 } 756 return size; 757 } 758 759 /* 760 * Find the handler for the prefix and dispatch its set() operation. 761 */ 762 int 763 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) 764 { 765 const struct xattr_handler *handler; 766 767 if (size == 0) 768 value = ""; /* empty EA, do not remove */ 769 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name); 770 if (!handler) 771 return -EOPNOTSUPP; 772 return handler->set(dentry, name, value, size, flags, handler->flags); 773 } 774 775 /* 776 * Find the handler for the prefix and dispatch its set() operation to remove 777 * any associated extended attribute. 778 */ 779 int 780 generic_removexattr(struct dentry *dentry, const char *name) 781 { 782 const struct xattr_handler *handler; 783 784 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name); 785 if (!handler) 786 return -EOPNOTSUPP; 787 return handler->set(dentry, name, NULL, 0, 788 XATTR_REPLACE, handler->flags); 789 } 790 791 EXPORT_SYMBOL(generic_getxattr); 792 EXPORT_SYMBOL(generic_listxattr); 793 EXPORT_SYMBOL(generic_setxattr); 794 EXPORT_SYMBOL(generic_removexattr); 795 796 /* 797 * Allocate new xattr and copy in the value; but leave the name to callers. 798 */ 799 struct simple_xattr *simple_xattr_alloc(const void *value, size_t size) 800 { 801 struct simple_xattr *new_xattr; 802 size_t len; 803 804 /* wrap around? */ 805 len = sizeof(*new_xattr) + size; 806 if (len <= sizeof(*new_xattr)) 807 return NULL; 808 809 new_xattr = kmalloc(len, GFP_KERNEL); 810 if (!new_xattr) 811 return NULL; 812 813 new_xattr->size = size; 814 memcpy(new_xattr->value, value, size); 815 return new_xattr; 816 } 817 818 /* 819 * xattr GET operation for in-memory/pseudo filesystems 820 */ 821 int simple_xattr_get(struct simple_xattrs *xattrs, const char *name, 822 void *buffer, size_t size) 823 { 824 struct simple_xattr *xattr; 825 int ret = -ENODATA; 826 827 spin_lock(&xattrs->lock); 828 list_for_each_entry(xattr, &xattrs->head, list) { 829 if (strcmp(name, xattr->name)) 830 continue; 831 832 ret = xattr->size; 833 if (buffer) { 834 if (size < xattr->size) 835 ret = -ERANGE; 836 else 837 memcpy(buffer, xattr->value, xattr->size); 838 } 839 break; 840 } 841 spin_unlock(&xattrs->lock); 842 return ret; 843 } 844 845 static int __simple_xattr_set(struct simple_xattrs *xattrs, const char *name, 846 const void *value, size_t size, int flags) 847 { 848 struct simple_xattr *xattr; 849 struct simple_xattr *uninitialized_var(new_xattr); 850 int err = 0; 851 852 /* value == NULL means remove */ 853 if (value) { 854 new_xattr = simple_xattr_alloc(value, size); 855 if (!new_xattr) 856 return -ENOMEM; 857 858 new_xattr->name = kstrdup(name, GFP_KERNEL); 859 if (!new_xattr->name) { 860 kfree(new_xattr); 861 return -ENOMEM; 862 } 863 } 864 865 spin_lock(&xattrs->lock); 866 list_for_each_entry(xattr, &xattrs->head, list) { 867 if (!strcmp(name, xattr->name)) { 868 if (flags & XATTR_CREATE) { 869 xattr = new_xattr; 870 err = -EEXIST; 871 } else if (new_xattr) { 872 list_replace(&xattr->list, &new_xattr->list); 873 } else { 874 list_del(&xattr->list); 875 } 876 goto out; 877 } 878 } 879 if (flags & XATTR_REPLACE) { 880 xattr = new_xattr; 881 err = -ENODATA; 882 } else { 883 list_add(&new_xattr->list, &xattrs->head); 884 xattr = NULL; 885 } 886 out: 887 spin_unlock(&xattrs->lock); 888 if (xattr) { 889 kfree(xattr->name); 890 kfree(xattr); 891 } 892 return err; 893 894 } 895 896 /** 897 * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems 898 * @xattrs: target simple_xattr list 899 * @name: name of the new extended attribute 900 * @value: value of the new xattr. If %NULL, will remove the attribute 901 * @size: size of the new xattr 902 * @flags: %XATTR_{CREATE|REPLACE} 903 * 904 * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails 905 * with -EEXIST. If %XATTR_REPLACE is set, the xattr should exist; 906 * otherwise, fails with -ENODATA. 907 * 908 * Returns 0 on success, -errno on failure. 909 */ 910 int simple_xattr_set(struct simple_xattrs *xattrs, const char *name, 911 const void *value, size_t size, int flags) 912 { 913 if (size == 0) 914 value = ""; /* empty EA, do not remove */ 915 return __simple_xattr_set(xattrs, name, value, size, flags); 916 } 917 918 /* 919 * xattr REMOVE operation for in-memory/pseudo filesystems 920 */ 921 int simple_xattr_remove(struct simple_xattrs *xattrs, const char *name) 922 { 923 return __simple_xattr_set(xattrs, name, NULL, 0, XATTR_REPLACE); 924 } 925 926 static bool xattr_is_trusted(const char *name) 927 { 928 return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN); 929 } 930 931 /* 932 * xattr LIST operation for in-memory/pseudo filesystems 933 */ 934 ssize_t simple_xattr_list(struct simple_xattrs *xattrs, char *buffer, 935 size_t size) 936 { 937 bool trusted = capable(CAP_SYS_ADMIN); 938 struct simple_xattr *xattr; 939 size_t used = 0; 940 941 spin_lock(&xattrs->lock); 942 list_for_each_entry(xattr, &xattrs->head, list) { 943 size_t len; 944 945 /* skip "trusted." attributes for unprivileged callers */ 946 if (!trusted && xattr_is_trusted(xattr->name)) 947 continue; 948 949 len = strlen(xattr->name) + 1; 950 used += len; 951 if (buffer) { 952 if (size < used) { 953 used = -ERANGE; 954 break; 955 } 956 memcpy(buffer, xattr->name, len); 957 buffer += len; 958 } 959 } 960 spin_unlock(&xattrs->lock); 961 962 return used; 963 } 964 965 /* 966 * Adds an extended attribute to the list 967 */ 968 void simple_xattr_list_add(struct simple_xattrs *xattrs, 969 struct simple_xattr *new_xattr) 970 { 971 spin_lock(&xattrs->lock); 972 list_add(&new_xattr->list, &xattrs->head); 973 spin_unlock(&xattrs->lock); 974 } 975