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/namei.h>
  15 #include <linux/security.h>
  16 #include <linux/syscalls.h>
  17 #include <linux/module.h>
  18 #include <linux/fsnotify.h>
  19 #include <linux/audit.h>
  20 #include <asm/uaccess.h>
  21
  22
  23 /*
  24  * Check permissions for extended attribute access.  This is a bit complicated
  25  * because different namespaces have very different rules.
  26  */
  27 static int
  28 xattr_permission(struct inode *inode, const char *name, int mask)
  29 {
  30         /*
  31          * We can never set or remove an extended attribute on a read-only
  32          * filesystem  or on an immutable / append-only inode.
  33          */
  34         if (mask & MAY_WRITE) {
  35                 if (IS_RDONLY(inode))
  36                         return -EROFS;
  37                 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
  38                         return -EPERM;
  39         }
  40
  41         /*
  42          * No restriction for security.* and system.* from the VFS.  Decision
  43          * on these is left to the underlying filesystem / security module.
  44          */
  45         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
  46             !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
  47                 return 0;
  48
  49         /*
  50          * The trusted.* namespace can only be accessed by a privileged user.
  51          */
  52         if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
  53                 return (capable(CAP_SYS_ADMIN) ? 0 : -EPERM);
  54
  55         /* In user.* namespace, only regular files and directories can have
  56          * extended attributes. For sticky directories, only the owner and
  57          * privileged user can write attributes.
  58          */
  59         if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
  60                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
  61                         return -EPERM;
  62                 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
  63                     (mask & MAY_WRITE) && (current->fsuid != inode->i_uid) &&
  64                     !capable(CAP_FOWNER))
  65                         return -EPERM;
  66         }
  67
  68         return permission(inode, mask, NULL);
  69 }
  70
  71 int
  72 vfs_setxattr(struct dentry *dentry, char *name, void *value,
  73                 size_t size, int flags)
  74 {
  75         struct inode *inode = dentry->d_inode;
  76         int error;
  77
  78         error = xattr_permission(inode, name, MAY_WRITE);
  79         if (error)
  80                 return error;
  81
  82         mutex_lock(&inode->i_mutex);
  83         error = security_inode_setxattr(dentry, name, value, size, flags);
  84         if (error)
  85                 goto out;
  86         error = -EOPNOTSUPP;
  87         if (inode->i_op->setxattr) {
  88                 error = inode->i_op->setxattr(dentry, name, value, size, flags);
  89                 if (!error) {
  90                         fsnotify_xattr(dentry);
  91                         security_inode_post_setxattr(dentry, name, value,
  92                                                      size, flags);
  93                 }
  94         } else if (!strncmp(name, XATTR_SECURITY_PREFIX,
  95                                 XATTR_SECURITY_PREFIX_LEN)) {
  96                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
  97                 error = security_inode_setsecurity(inode, suffix, value,
  98                                                    size, flags);
  99                 if (!error)
 100                         fsnotify_xattr(dentry);
 101         }
 102 out:
 103         mutex_unlock(&inode->i_mutex);
 104         return error;
 105 }
 106 EXPORT_SYMBOL_GPL(vfs_setxattr);
 107
 108 ssize_t
 109 vfs_getxattr(struct dentry *dentry, char *name, void *value, size_t size)
 110 {
 111         struct inode *inode = dentry->d_inode;
 112         int error;
 113
 114         error = xattr_permission(inode, name, MAY_READ);
 115         if (error)
 116                 return error;
 117
 118         error = security_inode_getxattr(dentry, name);
 119         if (error)
 120                 return error;
 121
 122         if (inode->i_op->getxattr)
 123                 error = inode->i_op->getxattr(dentry, name, value, size);
 124         else
 125                 error = -EOPNOTSUPP;
 126
 127         if (!strncmp(name, XATTR_SECURITY_PREFIX,
 128                                 XATTR_SECURITY_PREFIX_LEN)) {
 129                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
 130                 int ret = security_inode_getsecurity(inode, suffix, value,
 131                                                      size, error);
 132                 /*
 133                  * Only overwrite the return value if a security module
 134                  * is actually active.
 135                  */
 136                 if (ret != -EOPNOTSUPP)
 137                         error = ret;
 138         }
 139
 140         return error;
 141 }
 142 EXPORT_SYMBOL_GPL(vfs_getxattr);
 143
 144 ssize_t
 145 vfs_listxattr(struct dentry *d, char *list, size_t size)
 146 {
 147         ssize_t error;
 148
 149         error = security_inode_listxattr(d);
 150         if (error)
 151                 return error;
 152         error = -EOPNOTSUPP;
 153         if (d->d_inode->i_op && d->d_inode->i_op->listxattr) {
 154                 error = d->d_inode->i_op->listxattr(d, list, size);
 155         } else {
 156                 error = security_inode_listsecurity(d->d_inode, list, size);
 157                 if (size && error > size)
 158                         error = -ERANGE;
 159         }
 160         return error;
 161 }
 162 EXPORT_SYMBOL_GPL(vfs_listxattr);
 163
 164 int
 165 vfs_removexattr(struct dentry *dentry, char *name)
 166 {
 167         struct inode *inode = dentry->d_inode;
 168         int error;
 169
 170         if (!inode->i_op->removexattr)
 171                 return -EOPNOTSUPP;
 172
 173         error = xattr_permission(inode, name, MAY_WRITE);
 174         if (error)
 175                 return error;
 176
 177         error = security_inode_removexattr(dentry, name);
 178         if (error)
 179                 return error;
 180
 181         mutex_lock(&inode->i_mutex);
 182         error = inode->i_op->removexattr(dentry, name);
 183         mutex_unlock(&inode->i_mutex);
 184
 185         if (!error)
 186                 fsnotify_xattr(dentry);
 187         return error;
 188 }
 189 EXPORT_SYMBOL_GPL(vfs_removexattr);
 190
 191
 192 /*
 193  * Extended attribute SET operations
 194  */
 195 static long
 196 setxattr(struct dentry *d, char __user *name, void __user *value,
 197          size_t size, int flags)
 198 {
 199         int error;
 200         void *kvalue = NULL;
 201         char kname[XATTR_NAME_MAX + 1];
 202
 203         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
 204                 return -EINVAL;
 205
 206         error = strncpy_from_user(kname, name, sizeof(kname));
 207         if (error == 0 || error == sizeof(kname))
 208                 error = -ERANGE;
 209         if (error < 0)
 210                 return error;
 211
 212         if (size) {
 213                 if (size > XATTR_SIZE_MAX)
 214                         return -E2BIG;
 215                 kvalue = kmalloc(size, GFP_KERNEL);
 216                 if (!kvalue)
 217                         return -ENOMEM;
 218                 if (copy_from_user(kvalue, value, size)) {
 219                         kfree(kvalue);
 220                         return -EFAULT;
 221                 }
 222         }
 223
 224         error = vfs_setxattr(d, kname, kvalue, size, flags);
 225         kfree(kvalue);
 226         return error;
 227 }
 228
 229 asmlinkage long
 230 sys_setxattr(char __user *path, char __user *name, void __user *value,
 231              size_t size, int flags)
 232 {
 233         struct nameidata nd;
 234         int error;
 235
 236         error = user_path_walk(path, &nd);
 237         if (error)
 238                 return error;
 239         error = setxattr(nd.dentry, name, value, size, flags);
 240         path_release(&nd);
 241         return error;
 242 }
 243
 244 asmlinkage long
 245 sys_lsetxattr(char __user *path, char __user *name, void __user *value,
 246               size_t size, int flags)
 247 {
 248         struct nameidata nd;
 249         int error;
 250
 251         error = user_path_walk_link(path, &nd);
 252         if (error)
 253                 return error;
 254         error = setxattr(nd.dentry, name, value, size, flags);
 255         path_release(&nd);
 256         return error;
 257 }
 258
 259 asmlinkage long
 260 sys_fsetxattr(int fd, char __user *name, void __user *value,
 261               size_t size, int flags)
 262 {
 263         struct file *f;
 264         struct dentry *dentry;
 265         int error = -EBADF;
 266
 267         f = fget(fd);
 268         if (!f)
 269                 return error;
 270         dentry = f->f_path.dentry;
 271         audit_inode(NULL, dentry->d_inode);
 272         error = setxattr(dentry, name, value, size, flags);
 273         fput(f);
 274         return error;
 275 }
 276
 277 /*
 278  * Extended attribute GET operations
 279  */
 280 static ssize_t
 281 getxattr(struct dentry *d, char __user *name, void __user *value, size_t size)
 282 {
 283         ssize_t error;
 284         void *kvalue = NULL;
 285         char kname[XATTR_NAME_MAX + 1];
 286
 287         error = strncpy_from_user(kname, name, sizeof(kname));
 288         if (error == 0 || error == sizeof(kname))
 289                 error = -ERANGE;
 290         if (error < 0)
 291                 return error;
 292
 293         if (size) {
 294                 if (size > XATTR_SIZE_MAX)
 295                         size = XATTR_SIZE_MAX;
 296                 kvalue = kzalloc(size, GFP_KERNEL);
 297                 if (!kvalue)
 298                         return -ENOMEM;
 299         }
 300
 301         error = vfs_getxattr(d, kname, kvalue, size);
 302         if (error > 0) {
 303                 if (size && copy_to_user(value, kvalue, error))
 304                         error = -EFAULT;
 305         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
 306                 /* The file system tried to returned a value bigger
 307                    than XATTR_SIZE_MAX bytes. Not possible. */
 308                 error = -E2BIG;
 309         }
 310         kfree(kvalue);
 311         return error;
 312 }
 313
 314 asmlinkage ssize_t
 315 sys_getxattr(char __user *path, char __user *name, void __user *value,
 316              size_t size)
 317 {
 318         struct nameidata nd;
 319         ssize_t error;
 320
 321         error = user_path_walk(path, &nd);
 322         if (error)
 323                 return error;
 324         error = getxattr(nd.dentry, name, value, size);
 325         path_release(&nd);
 326         return error;
 327 }
 328
 329 asmlinkage ssize_t
 330 sys_lgetxattr(char __user *path, char __user *name, void __user *value,
 331               size_t size)
 332 {
 333         struct nameidata nd;
 334         ssize_t error;
 335
 336         error = user_path_walk_link(path, &nd);
 337         if (error)
 338                 return error;
 339         error = getxattr(nd.dentry, name, value, size);
 340         path_release(&nd);
 341         return error;
 342 }
 343
 344 asmlinkage ssize_t
 345 sys_fgetxattr(int fd, char __user *name, void __user *value, size_t size)
 346 {
 347         struct file *f;
 348         ssize_t error = -EBADF;
 349
 350         f = fget(fd);
 351         if (!f)
 352                 return error;
 353         error = getxattr(f->f_path.dentry, name, value, size);
 354         fput(f);
 355         return error;
 356 }
 357
 358 /*
 359  * Extended attribute LIST operations
 360  */
 361 static ssize_t
 362 listxattr(struct dentry *d, char __user *list, size_t size)
 363 {
 364         ssize_t error;
 365         char *klist = NULL;
 366
 367         if (size) {
 368                 if (size > XATTR_LIST_MAX)
 369                         size = XATTR_LIST_MAX;
 370                 klist = kmalloc(size, GFP_KERNEL);
 371                 if (!klist)
 372                         return -ENOMEM;
 373         }
 374
 375         error = vfs_listxattr(d, klist, size);
 376         if (error > 0) {
 377                 if (size && copy_to_user(list, klist, error))
 378                         error = -EFAULT;
 379         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
 380                 /* The file system tried to returned a list bigger
 381                    than XATTR_LIST_MAX bytes. Not possible. */
 382                 error = -E2BIG;
 383         }
 384         kfree(klist);
 385         return error;
 386 }
 387
 388 asmlinkage ssize_t
 389 sys_listxattr(char __user *path, char __user *list, size_t size)
 390 {
 391         struct nameidata nd;
 392         ssize_t error;
 393
 394         error = user_path_walk(path, &nd);
 395         if (error)
 396                 return error;
 397         error = listxattr(nd.dentry, list, size);
 398         path_release(&nd);
 399         return error;
 400 }
 401
 402 asmlinkage ssize_t
 403 sys_llistxattr(char __user *path, char __user *list, size_t size)
 404 {
 405         struct nameidata nd;
 406         ssize_t error;
 407
 408         error = user_path_walk_link(path, &nd);
 409         if (error)
 410                 return error;
 411         error = listxattr(nd.dentry, list, size);
 412         path_release(&nd);
 413         return error;
 414 }
 415
 416 asmlinkage ssize_t
 417 sys_flistxattr(int fd, char __user *list, size_t size)
 418 {
 419         struct file *f;
 420         ssize_t error = -EBADF;
 421
 422         f = fget(fd);
 423         if (!f)
 424                 return error;
 425         error = listxattr(f->f_path.dentry, list, size);
 426         fput(f);
 427         return error;
 428 }
 429
 430 /*
 431  * Extended attribute REMOVE operations
 432  */
 433 static long
 434 removexattr(struct dentry *d, char __user *name)
 435 {
 436         int error;
 437         char kname[XATTR_NAME_MAX + 1];
 438
 439         error = strncpy_from_user(kname, name, sizeof(kname));
 440         if (error == 0 || error == sizeof(kname))
 441                 error = -ERANGE;
 442         if (error < 0)
 443                 return error;
 444
 445         return vfs_removexattr(d, kname);
 446 }
 447
 448 asmlinkage long
 449 sys_removexattr(char __user *path, char __user *name)
 450 {
 451         struct nameidata nd;
 452         int error;
 453
 454         error = user_path_walk(path, &nd);
 455         if (error)
 456                 return error;
 457         error = removexattr(nd.dentry, name);
 458         path_release(&nd);
 459         return error;
 460 }
 461
 462 asmlinkage long
 463 sys_lremovexattr(char __user *path, char __user *name)
 464 {
 465         struct nameidata nd;
 466         int error;
 467
 468         error = user_path_walk_link(path, &nd);
 469         if (error)
 470                 return error;
 471         error = removexattr(nd.dentry, name);
 472         path_release(&nd);
 473         return error;
 474 }
 475
 476 asmlinkage long
 477 sys_fremovexattr(int fd, char __user *name)
 478 {
 479         struct file *f;
 480         struct dentry *dentry;
 481         int error = -EBADF;
 482
 483         f = fget(fd);
 484         if (!f)
 485                 return error;
 486         dentry = f->f_path.dentry;
 487         audit_inode(NULL, dentry->d_inode);
 488         error = removexattr(dentry, name);
 489         fput(f);
 490         return error;
 491 }
 492
 493
 494 static const char *
 495 strcmp_prefix(const char *a, const char *a_prefix)
 496 {
 497         while (*a_prefix && *a == *a_prefix) {
 498                 a++;
 499                 a_prefix++;
 500         }
 501         return *a_prefix ? NULL : a;
 502 }
 503
 504 /*
 505  * In order to implement different sets of xattr operations for each xattr
 506  * prefix with the generic xattr API, a filesystem should create a
 507  * null-terminated array of struct xattr_handler (one for each prefix) and
 508  * hang a pointer to it off of the s_xattr field of the superblock.
 509  *
 510  * The generic_fooxattr() functions will use this list to dispatch xattr
 511  * operations to the correct xattr_handler.
 512  */
 513 #define for_each_xattr_handler(handlers, handler)               \
 514                 for ((handler) = *(handlers)++;                 \
 515                         (handler) != NULL;                      \
 516                         (handler) = *(handlers)++)
 517
 518 /*
 519  * Find the xattr_handler with the matching prefix.
 520  */
 521 static struct xattr_handler *
 522 xattr_resolve_name(struct xattr_handler **handlers, const char **name)
 523 {
 524         struct xattr_handler *handler;
 525
 526         if (!*name)
 527                 return NULL;
 528
 529         for_each_xattr_handler(handlers, handler) {
 530                 const char *n = strcmp_prefix(*name, handler->prefix);
 531                 if (n) {
 532                         *name = n;
 533                         break;
 534                 }
 535         }
 536         return handler;
 537 }
 538
 539 /*
 540  * Find the handler for the prefix and dispatch its get() operation.
 541  */
 542 ssize_t
 543 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
 544 {
 545         struct xattr_handler *handler;
 546         struct inode *inode = dentry->d_inode;
 547
 548         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 549         if (!handler)
 550                 return -EOPNOTSUPP;
 551         return handler->get(inode, name, buffer, size);
 552 }
 553
 554 /*
 555  * Combine the results of the list() operation from every xattr_handler in the
 556  * list.
 557  */
 558 ssize_t
 559 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 560 {
 561         struct inode *inode = dentry->d_inode;
 562         struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
 563         unsigned int size = 0;
 564
 565         if (!buffer) {
 566                 for_each_xattr_handler(handlers, handler)
 567                         size += handler->list(inode, NULL, 0, NULL, 0);
 568         } else {
 569                 char *buf = buffer;
 570
 571                 for_each_xattr_handler(handlers, handler) {
 572                         size = handler->list(inode, buf, buffer_size, NULL, 0);
 573                         if (size > buffer_size)
 574                                 return -ERANGE;
 575                         buf += size;
 576                         buffer_size -= size;
 577                 }
 578                 size = buf - buffer;
 579         }
 580         return size;
 581 }
 582
 583 /*
 584  * Find the handler for the prefix and dispatch its set() operation.
 585  */
 586 int
 587 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
 588 {
 589         struct xattr_handler *handler;
 590         struct inode *inode = dentry->d_inode;
 591
 592         if (size == 0)
 593                 value = "";  /* empty EA, do not remove */
 594         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 595         if (!handler)
 596                 return -EOPNOTSUPP;
 597         return handler->set(inode, name, value, size, flags);
 598 }
 599
 600 /*
 601  * Find the handler for the prefix and dispatch its set() operation to remove
 602  * any associated extended attribute.
 603  */
 604 int
 605 generic_removexattr(struct dentry *dentry, const char *name)
 606 {
 607         struct xattr_handler *handler;
 608         struct inode *inode = dentry->d_inode;
 609
 610         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 611         if (!handler)
 612                 return -EOPNOTSUPP;
 613         return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
 614 }
 615
 616 EXPORT_SYMBOL(generic_getxattr);
 617 EXPORT_SYMBOL(generic_listxattr);
 618 EXPORT_SYMBOL(generic_setxattr);
 619 EXPORT_SYMBOL(generic_removexattr);