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