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 <asm/uaccess.h>
  21
  22 /*
  23  * Extended attribute SET operations
  24  */
  25 static long
  26 setxattr(struct dentry *d, char __user *name, void __user *value,
  27          size_t size, int flags)
  28 {
  29         int error;
  30         void *kvalue = NULL;
  31         char kname[XATTR_NAME_MAX + 1];
  32
  33         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
  34                 return -EINVAL;
  35
  36         error = strncpy_from_user(kname, name, sizeof(kname));
  37         if (error == 0 || error == sizeof(kname))
  38                 error = -ERANGE;
  39         if (error < 0)
  40                 return error;
  41
  42         if (size) {
  43                 if (size > XATTR_SIZE_MAX)
  44                         return -E2BIG;
  45                 kvalue = kmalloc(size, GFP_KERNEL);
  46                 if (!kvalue)
  47                         return -ENOMEM;
  48                 if (copy_from_user(kvalue, value, size)) {
  49                         kfree(kvalue);
  50                         return -EFAULT;
  51                 }
  52         }
  53
  54         mutex_lock(&d->d_inode->i_mutex);
  55         error = security_inode_setxattr(d, kname, kvalue, size, flags);
  56         if (error)
  57                 goto out;
  58         error = -EOPNOTSUPP;
  59         if (d->d_inode->i_op && d->d_inode->i_op->setxattr) {
  60                 error = d->d_inode->i_op->setxattr(d, kname, kvalue,
  61                                                    size, flags);
  62                 if (!error) {
  63                         fsnotify_xattr(d);
  64                         security_inode_post_setxattr(d, kname, kvalue,
  65                                                      size, flags);
  66                 }
  67         } else if (!strncmp(kname, XATTR_SECURITY_PREFIX,
  68                             sizeof XATTR_SECURITY_PREFIX - 1)) {
  69                 const char *suffix = kname + sizeof XATTR_SECURITY_PREFIX - 1;
  70                 error = security_inode_setsecurity(d->d_inode, suffix, kvalue,
  71                                                    size, flags);
  72                 if (!error)
  73                         fsnotify_xattr(d);
  74         }
  75 out:
  76         mutex_unlock(&d->d_inode->i_mutex);
  77         kfree(kvalue);
  78         return error;
  79 }
  80
  81 asmlinkage long
  82 sys_setxattr(char __user *path, char __user *name, void __user *value,
  83              size_t size, int flags)
  84 {
  85         struct nameidata nd;
  86         int error;
  87
  88         error = user_path_walk(path, &nd);
  89         if (error)
  90                 return error;
  91         error = setxattr(nd.dentry, name, value, size, flags);
  92         path_release(&nd);
  93         return error;
  94 }
  95
  96 asmlinkage long
  97 sys_lsetxattr(char __user *path, char __user *name, void __user *value,
  98               size_t size, int flags)
  99 {
 100         struct nameidata nd;
 101         int error;
 102
 103         error = user_path_walk_link(path, &nd);
 104         if (error)
 105                 return error;
 106         error = setxattr(nd.dentry, name, value, size, flags);
 107         path_release(&nd);
 108         return error;
 109 }
 110
 111 asmlinkage long
 112 sys_fsetxattr(int fd, char __user *name, void __user *value,
 113               size_t size, int flags)
 114 {
 115         struct file *f;
 116         int error = -EBADF;
 117
 118         f = fget(fd);
 119         if (!f)
 120                 return error;
 121         error = setxattr(f->f_dentry, name, value, size, flags);
 122         fput(f);
 123         return error;
 124 }
 125
 126 /*
 127  * Extended attribute GET operations
 128  */
 129 static ssize_t
 130 getxattr(struct dentry *d, char __user *name, void __user *value, size_t size)
 131 {
 132         ssize_t error;
 133         void *kvalue = NULL;
 134         char kname[XATTR_NAME_MAX + 1];
 135
 136         error = strncpy_from_user(kname, name, sizeof(kname));
 137         if (error == 0 || error == sizeof(kname))
 138                 error = -ERANGE;
 139         if (error < 0)
 140                 return error;
 141
 142         if (size) {
 143                 if (size > XATTR_SIZE_MAX)
 144                         size = XATTR_SIZE_MAX;
 145                 kvalue = kzalloc(size, GFP_KERNEL);
 146                 if (!kvalue)
 147                         return -ENOMEM;
 148         }
 149
 150         error = security_inode_getxattr(d, kname);
 151         if (error)
 152                 goto out;
 153         error = -EOPNOTSUPP;
 154         if (d->d_inode->i_op && d->d_inode->i_op->getxattr)
 155                 error = d->d_inode->i_op->getxattr(d, kname, kvalue, size);
 156
 157         if (!strncmp(kname, XATTR_SECURITY_PREFIX,
 158                      sizeof XATTR_SECURITY_PREFIX - 1)) {
 159                 const char *suffix = kname + sizeof XATTR_SECURITY_PREFIX - 1;
 160                 int rv = security_inode_getsecurity(d->d_inode, suffix, kvalue,
 161                                                     size, error);
 162                 /* Security module active: overwrite error value */
 163                 if (rv != -EOPNOTSUPP)
 164                         error = rv;
 165         }
 166         if (error > 0) {
 167                 if (size && copy_to_user(value, kvalue, error))
 168                         error = -EFAULT;
 169         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
 170                 /* The file system tried to returned a value bigger
 171                    than XATTR_SIZE_MAX bytes. Not possible. */
 172                 error = -E2BIG;
 173         }
 174 out:
 175         kfree(kvalue);
 176         return error;
 177 }
 178
 179 asmlinkage ssize_t
 180 sys_getxattr(char __user *path, char __user *name, void __user *value,
 181              size_t size)
 182 {
 183         struct nameidata nd;
 184         ssize_t error;
 185
 186         error = user_path_walk(path, &nd);
 187         if (error)
 188                 return error;
 189         error = getxattr(nd.dentry, name, value, size);
 190         path_release(&nd);
 191         return error;
 192 }
 193
 194 asmlinkage ssize_t
 195 sys_lgetxattr(char __user *path, char __user *name, void __user *value,
 196               size_t size)
 197 {
 198         struct nameidata nd;
 199         ssize_t error;
 200
 201         error = user_path_walk_link(path, &nd);
 202         if (error)
 203                 return error;
 204         error = getxattr(nd.dentry, name, value, size);
 205         path_release(&nd);
 206         return error;
 207 }
 208
 209 asmlinkage ssize_t
 210 sys_fgetxattr(int fd, char __user *name, void __user *value, size_t size)
 211 {
 212         struct file *f;
 213         ssize_t error = -EBADF;
 214
 215         f = fget(fd);
 216         if (!f)
 217                 return error;
 218         error = getxattr(f->f_dentry, name, value, size);
 219         fput(f);
 220         return error;
 221 }
 222
 223 /*
 224  * Extended attribute LIST operations
 225  */
 226 static ssize_t
 227 listxattr(struct dentry *d, char __user *list, size_t size)
 228 {
 229         ssize_t error;
 230         char *klist = NULL;
 231
 232         if (size) {
 233                 if (size > XATTR_LIST_MAX)
 234                         size = XATTR_LIST_MAX;
 235                 klist = kmalloc(size, GFP_KERNEL);
 236                 if (!klist)
 237                         return -ENOMEM;
 238         }
 239
 240         error = security_inode_listxattr(d);
 241         if (error)
 242                 goto out;
 243         error = -EOPNOTSUPP;
 244         if (d->d_inode->i_op && d->d_inode->i_op->listxattr) {
 245                 error = d->d_inode->i_op->listxattr(d, klist, size);
 246         } else {
 247                 error = security_inode_listsecurity(d->d_inode, klist, size);
 248                 if (size && error > size)
 249                         error = -ERANGE;
 250         }
 251         if (error > 0) {
 252                 if (size && copy_to_user(list, klist, error))
 253                         error = -EFAULT;
 254         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
 255                 /* The file system tried to returned a list bigger
 256                    than XATTR_LIST_MAX bytes. Not possible. */
 257                 error = -E2BIG;
 258         }
 259 out:
 260         kfree(klist);
 261         return error;
 262 }
 263
 264 asmlinkage ssize_t
 265 sys_listxattr(char __user *path, char __user *list, size_t size)
 266 {
 267         struct nameidata nd;
 268         ssize_t error;
 269
 270         error = user_path_walk(path, &nd);
 271         if (error)
 272                 return error;
 273         error = listxattr(nd.dentry, list, size);
 274         path_release(&nd);
 275         return error;
 276 }
 277
 278 asmlinkage ssize_t
 279 sys_llistxattr(char __user *path, char __user *list, size_t size)
 280 {
 281         struct nameidata nd;
 282         ssize_t error;
 283
 284         error = user_path_walk_link(path, &nd);
 285         if (error)
 286                 return error;
 287         error = listxattr(nd.dentry, list, size);
 288         path_release(&nd);
 289         return error;
 290 }
 291
 292 asmlinkage ssize_t
 293 sys_flistxattr(int fd, char __user *list, size_t size)
 294 {
 295         struct file *f;
 296         ssize_t error = -EBADF;
 297
 298         f = fget(fd);
 299         if (!f)
 300                 return error;
 301         error = listxattr(f->f_dentry, list, size);
 302         fput(f);
 303         return error;
 304 }
 305
 306 /*
 307  * Extended attribute REMOVE operations
 308  */
 309 static long
 310 removexattr(struct dentry *d, char __user *name)
 311 {
 312         int error;
 313         char kname[XATTR_NAME_MAX + 1];
 314
 315         error = strncpy_from_user(kname, name, sizeof(kname));
 316         if (error == 0 || error == sizeof(kname))
 317                 error = -ERANGE;
 318         if (error < 0)
 319                 return error;
 320
 321         error = -EOPNOTSUPP;
 322         if (d->d_inode->i_op && d->d_inode->i_op->removexattr) {
 323                 error = security_inode_removexattr(d, kname);
 324                 if (error)
 325                         goto out;
 326                 mutex_lock(&d->d_inode->i_mutex);
 327                 error = d->d_inode->i_op->removexattr(d, kname);
 328                 mutex_unlock(&d->d_inode->i_mutex);
 329                 if (!error)
 330                         fsnotify_xattr(d);
 331         }
 332 out:
 333         return error;
 334 }
 335
 336 asmlinkage long
 337 sys_removexattr(char __user *path, char __user *name)
 338 {
 339         struct nameidata nd;
 340         int error;
 341
 342         error = user_path_walk(path, &nd);
 343         if (error)
 344                 return error;
 345         error = removexattr(nd.dentry, name);
 346         path_release(&nd);
 347         return error;
 348 }
 349
 350 asmlinkage long
 351 sys_lremovexattr(char __user *path, char __user *name)
 352 {
 353         struct nameidata nd;
 354         int error;
 355
 356         error = user_path_walk_link(path, &nd);
 357         if (error)
 358                 return error;
 359         error = removexattr(nd.dentry, name);
 360         path_release(&nd);
 361         return error;
 362 }
 363
 364 asmlinkage long
 365 sys_fremovexattr(int fd, char __user *name)
 366 {
 367         struct file *f;
 368         int error = -EBADF;
 369
 370         f = fget(fd);
 371         if (!f)
 372                 return error;
 373         error = removexattr(f->f_dentry, name);
 374         fput(f);
 375         return error;
 376 }
 377
 378
 379 static const char *
 380 strcmp_prefix(const char *a, const char *a_prefix)
 381 {
 382         while (*a_prefix && *a == *a_prefix) {
 383                 a++;
 384                 a_prefix++;
 385         }
 386         return *a_prefix ? NULL : a;
 387 }
 388
 389 /*
 390  * In order to implement different sets of xattr operations for each xattr
 391  * prefix with the generic xattr API, a filesystem should create a
 392  * null-terminated array of struct xattr_handler (one for each prefix) and
 393  * hang a pointer to it off of the s_xattr field of the superblock.
 394  *
 395  * The generic_fooxattr() functions will use this list to dispatch xattr
 396  * operations to the correct xattr_handler.
 397  */
 398 #define for_each_xattr_handler(handlers, handler)               \
 399                 for ((handler) = *(handlers)++;                 \
 400                         (handler) != NULL;                      \
 401                         (handler) = *(handlers)++)
 402
 403 /*
 404  * Find the xattr_handler with the matching prefix.
 405  */
 406 static struct xattr_handler *
 407 xattr_resolve_name(struct xattr_handler **handlers, const char **name)
 408 {
 409         struct xattr_handler *handler;
 410
 411         if (!*name)
 412                 return NULL;
 413
 414         for_each_xattr_handler(handlers, handler) {
 415                 const char *n = strcmp_prefix(*name, handler->prefix);
 416                 if (n) {
 417                         *name = n;
 418                         break;
 419                 }
 420         }
 421         return handler;
 422 }
 423
 424 /*
 425  * Find the handler for the prefix and dispatch its get() operation.
 426  */
 427 ssize_t
 428 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
 429 {
 430         struct xattr_handler *handler;
 431         struct inode *inode = dentry->d_inode;
 432
 433         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 434         if (!handler)
 435                 return -EOPNOTSUPP;
 436         return handler->get(inode, name, buffer, size);
 437 }
 438
 439 /*
 440  * Combine the results of the list() operation from every xattr_handler in the
 441  * list.
 442  */
 443 ssize_t
 444 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 445 {
 446         struct inode *inode = dentry->d_inode;
 447         struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
 448         unsigned int size = 0;
 449
 450         if (!buffer) {
 451                 for_each_xattr_handler(handlers, handler)
 452                         size += handler->list(inode, NULL, 0, NULL, 0);
 453         } else {
 454                 char *buf = buffer;
 455
 456                 for_each_xattr_handler(handlers, handler) {
 457                         size = handler->list(inode, buf, buffer_size, NULL, 0);
 458                         if (size > buffer_size)
 459                                 return -ERANGE;
 460                         buf += size;
 461                         buffer_size -= size;
 462                 }
 463                 size = buf - buffer;
 464         }
 465         return size;
 466 }
 467
 468 /*
 469  * Find the handler for the prefix and dispatch its set() operation.
 470  */
 471 int
 472 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
 473 {
 474         struct xattr_handler *handler;
 475         struct inode *inode = dentry->d_inode;
 476
 477         if (size == 0)
 478                 value = "";  /* empty EA, do not remove */
 479         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 480         if (!handler)
 481                 return -EOPNOTSUPP;
 482         return handler->set(inode, name, value, size, flags);
 483 }
 484
 485 /*
 486  * Find the handler for the prefix and dispatch its set() operation to remove
 487  * any associated extended attribute.
 488  */
 489 int
 490 generic_removexattr(struct dentry *dentry, const char *name)
 491 {
 492         struct xattr_handler *handler;
 493         struct inode *inode = dentry->d_inode;
 494
 495         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
 496         if (!handler)
 497                 return -EOPNOTSUPP;
 498         return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
 499 }
 500
 501 EXPORT_SYMBOL(generic_getxattr);
 502 EXPORT_SYMBOL(generic_listxattr);
 503 EXPORT_SYMBOL(generic_setxattr);
 504 EXPORT_SYMBOL(generic_removexattr);