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