xattr.c 23.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
  File: fs/xattr.c

  Extended attribute handling.

  Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
  Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
  Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
 */
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/xattr.h>
14
#include <linux/mount.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16
#include <linux/namei.h>
#include <linux/security.h>
17
#include <linux/evm.h>
Linus Torvalds's avatar
Linus Torvalds committed
18
#include <linux/syscalls.h>
19
#include <linux/export.h>
Robert Love's avatar
Robert Love committed
20
#include <linux/fsnotify.h>
21
#include <linux/audit.h>
22
#include <linux/vmalloc.h>
23
#include <linux/posix_acl_xattr.h>
Linus Torvalds's avatar
Linus Torvalds committed
24

25
#include <asm/uaccess.h>
26

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
/*
 * Check permissions for extended attribute access.  This is a bit complicated
 * because different namespaces have very different rules.
 */
static int
xattr_permission(struct inode *inode, const char *name, int mask)
{
	/*
	 * We can never set or remove an extended attribute on a read-only
	 * filesystem  or on an immutable / append-only inode.
	 */
	if (mask & MAY_WRITE) {
		if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
			return -EPERM;
	}

	/*
	 * No restriction for security.* and system.* from the VFS.  Decision
	 * on these is left to the underlying filesystem / security module.
	 */
	if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
	    !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
		return 0;

	/*
52
	 * The trusted.* namespace can only be accessed by privileged users.
53
	 */
54 55 56 57 58
	if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
		if (!capable(CAP_SYS_ADMIN))
			return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
		return 0;
	}
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 71 72
			return -EPERM;
	}

73
	return inode_permission(inode, mask);
74 75
}

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
/**
 *  __vfs_setxattr_noperm - perform setxattr operation without performing
 *  permission checks.
 *
 *  @dentry - object to perform setxattr on
 *  @name - xattr name to set
 *  @value - value to set @name to
 *  @size - size of @value
 *  @flags - flags to pass into filesystem operations
 *
 *  returns the result of the internal setxattr or setsecurity operations.
 *
 *  This function requires the caller to lock the inode's i_mutex before it
 *  is executed. It also assumes that the caller will make the appropriate
 *  permission checks.
 */
int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
		const void *value, size_t size, int flags)
94 95
{
	struct inode *inode = dentry->d_inode;
96
	int error = -EOPNOTSUPP;
97 98
	int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
				   XATTR_SECURITY_PREFIX_LEN);
99

100 101
	if (issec)
		inode->i_flags &= ~S_NOSEC;
102 103 104 105 106 107 108
	if (inode->i_op->setxattr) {
		error = inode->i_op->setxattr(dentry, name, value, size, flags);
		if (!error) {
			fsnotify_xattr(dentry);
			security_inode_post_setxattr(dentry, name, value,
						     size, flags);
		}
109
	} else if (issec) {
110
		const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
111 112 113 114 115
		error = security_inode_setsecurity(inode, suffix, value,
						   size, flags);
		if (!error)
			fsnotify_xattr(dentry);
	}
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

	return error;
}


int
vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
		size_t size, int flags)
{
	struct inode *inode = dentry->d_inode;
	int error;

	error = xattr_permission(inode, name, MAY_WRITE);
	if (error)
		return error;

	mutex_lock(&inode->i_mutex);
	error = security_inode_setxattr(dentry, name, value, size, flags);
	if (error)
		goto out;

	error = __vfs_setxattr_noperm(dentry, name, value, size, flags);

139 140 141 142 143 144
out:
	mutex_unlock(&inode->i_mutex);
	return error;
}
EXPORT_SYMBOL_GPL(vfs_setxattr);

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
ssize_t
xattr_getsecurity(struct inode *inode, const char *name, void *value,
			size_t size)
{
	void *buffer = NULL;
	ssize_t len;

	if (!value || !size) {
		len = security_inode_getsecurity(inode, name, &buffer, false);
		goto out_noalloc;
	}

	len = security_inode_getsecurity(inode, name, &buffer, true);
	if (len < 0)
		return len;
	if (size < len) {
		len = -ERANGE;
		goto out;
	}
	memcpy(value, buffer, len);
out:
	security_release_secctx(buffer, len);
out_noalloc:
	return len;
}
EXPORT_SYMBOL_GPL(xattr_getsecurity);

172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
/*
 * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
 *
 * Allocate memory, if not already allocated, or re-allocate correct size,
 * before retrieving the extended attribute.
 *
 * Returns the result of alloc, if failed, or the getxattr operation.
 */
ssize_t
vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
		   size_t xattr_size, gfp_t flags)
{
	struct inode *inode = dentry->d_inode;
	char *value = *xattr_value;
	int error;

	error = xattr_permission(inode, name, MAY_READ);
	if (error)
		return error;

	if (!inode->i_op->getxattr)
		return -EOPNOTSUPP;

	error = inode->i_op->getxattr(dentry, name, NULL, 0);
	if (error < 0)
		return error;

	if (!value || (error > xattr_size)) {
		value = krealloc(*xattr_value, error + 1, flags);
		if (!value)
			return -ENOMEM;
		memset(value, 0, error + 1);
	}

	error = inode->i_op->getxattr(dentry, name, value, error);
	*xattr_value = value;
	return error;
}
210
EXPORT_SYMBOL(vfs_getxattr_alloc);
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

/* Compare an extended attribute value with the given value */
int vfs_xattr_cmp(struct dentry *dentry, const char *xattr_name,
		  const char *value, size_t size, gfp_t flags)
{
	char *xattr_value = NULL;
	int rc;

	rc = vfs_getxattr_alloc(dentry, xattr_name, &xattr_value, 0, flags);
	if (rc < 0)
		return rc;

	if ((rc != size) || (memcmp(xattr_value, value, rc) != 0))
		rc = -EINVAL;
	else
		rc = 0;
	kfree(xattr_value);
	return rc;
}

231
ssize_t
232
vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
233 234 235 236
{
	struct inode *inode = dentry->d_inode;
	int error;

237 238 239 240
	error = xattr_permission(inode, name, MAY_READ);
	if (error)
		return error;

241 242 243 244 245
	error = security_inode_getxattr(dentry, name);
	if (error)
		return error;

	if (!strncmp(name, XATTR_SECURITY_PREFIX,
246 247
				XATTR_SECURITY_PREFIX_LEN)) {
		const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
248
		int ret = xattr_getsecurity(inode, suffix, value, size);
249 250 251 252
		/*
		 * Only overwrite the return value if a security module
		 * is actually active.
		 */
253 254 255
		if (ret == -EOPNOTSUPP)
			goto nolsm;
		return ret;
256
	}
257 258 259 260 261
nolsm:
	if (inode->i_op->getxattr)
		error = inode->i_op->getxattr(dentry, name, value, size);
	else
		error = -EOPNOTSUPP;
262 263 264 265 266

	return error;
}
EXPORT_SYMBOL_GPL(vfs_getxattr);

267 268 269 270 271 272 273 274 275
ssize_t
vfs_listxattr(struct dentry *d, char *list, size_t size)
{
	ssize_t error;

	error = security_inode_listxattr(d);
	if (error)
		return error;
	error = -EOPNOTSUPP;
Al Viro's avatar
Al Viro committed
276
	if (d->d_inode->i_op->listxattr) {
277 278 279 280 281 282 283 284 285 286
		error = d->d_inode->i_op->listxattr(d, list, size);
	} else {
		error = security_inode_listsecurity(d->d_inode, list, size);
		if (size && error > size)
			error = -ERANGE;
	}
	return error;
}
EXPORT_SYMBOL_GPL(vfs_listxattr);

287
int
288
vfs_removexattr(struct dentry *dentry, const char *name)
289 290 291 292 293 294 295
{
	struct inode *inode = dentry->d_inode;
	int error;

	if (!inode->i_op->removexattr)
		return -EOPNOTSUPP;

296 297 298 299
	error = xattr_permission(inode, name, MAY_WRITE);
	if (error)
		return error;

300
	mutex_lock(&inode->i_mutex);
301
	error = security_inode_removexattr(dentry, name);
302 303
	if (error) {
		mutex_unlock(&inode->i_mutex);
304
		return error;
305
	}
306 307 308 309

	error = inode->i_op->removexattr(dentry, name);
	mutex_unlock(&inode->i_mutex);

310
	if (!error) {
311
		fsnotify_xattr(dentry);
312 313
		evm_inode_post_removexattr(dentry, name);
	}
314 315 316 317 318
	return error;
}
EXPORT_SYMBOL_GPL(vfs_removexattr);


Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322
/*
 * Extended attribute SET operations
 */
static long
323
setxattr(struct dentry *d, const char __user *name, const void __user *value,
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326 327
	 size_t size, int flags)
{
	int error;
	void *kvalue = NULL;
328
	void *vvalue = NULL;	/* If non-NULL, we used vmalloc() */
Linus Torvalds's avatar
Linus Torvalds committed
329 330 331 332 333 334 335 336 337 338 339 340 341 342
	char kname[XATTR_NAME_MAX + 1];

	if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
		return -EINVAL;

	error = strncpy_from_user(kname, name, sizeof(kname));
	if (error == 0 || error == sizeof(kname))
		error = -ERANGE;
	if (error < 0)
		return error;

	if (size) {
		if (size > XATTR_SIZE_MAX)
			return -E2BIG;
343 344 345 346 347 348 349 350 351 352 353
		kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
		if (!kvalue) {
			vvalue = vmalloc(size);
			if (!vvalue)
				return -ENOMEM;
			kvalue = vvalue;
		}
		if (copy_from_user(kvalue, value, size)) {
			error = -EFAULT;
			goto out;
		}
354 355 356
		if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
		    (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
			posix_acl_fix_xattr_from_user(kvalue, size);
Linus Torvalds's avatar
Linus Torvalds committed
357 358
	}

359
	error = vfs_setxattr(d, kname, kvalue, size, flags);
360 361 362 363 364
out:
	if (vvalue)
		vfree(vvalue);
	else
		kfree(kvalue);
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367
	return error;
}

368 369 370
SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
		const char __user *, name, const void __user *, value,
		size_t, size, int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
371
{
372
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
373
	int error;
374 375 376
	unsigned int lookup_flags = LOOKUP_FOLLOW;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
377 378
	if (error)
		return error;
379
	error = mnt_want_write(path.mnt);
380
	if (!error) {
381 382
		error = setxattr(path.dentry, name, value, size, flags);
		mnt_drop_write(path.mnt);
383
	}
384
	path_put(&path);
385 386 387 388
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391
	return error;
}

392 393 394
SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
		const char __user *, name, const void __user *, value,
		size_t, size, int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
395
{
396
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
397
	int error;
398 399 400
	unsigned int lookup_flags = 0;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
401 402
	if (error)
		return error;
403
	error = mnt_want_write(path.mnt);
404
	if (!error) {
405 406
		error = setxattr(path.dentry, name, value, size, flags);
		mnt_drop_write(path.mnt);
407
	}
408
	path_put(&path);
409 410 411 412
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415
	return error;
}

416 417
SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
		const void __user *,value, size_t, size, int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
418
{
419
	struct fd f = fdget(fd);
420
	struct dentry *dentry;
Linus Torvalds's avatar
Linus Torvalds committed
421 422
	int error = -EBADF;

423
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
424
		return error;
425
	dentry = f.file->f_path.dentry;
426
	audit_inode(NULL, dentry, 0);
427
	error = mnt_want_write_file(f.file);
428 429
	if (!error) {
		error = setxattr(dentry, name, value, size, flags);
430
		mnt_drop_write_file(f.file);
431
	}
432
	fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437 438 439
	return error;
}

/*
 * Extended attribute GET operations
 */
static ssize_t
440 441
getxattr(struct dentry *d, const char __user *name, void __user *value,
	 size_t size)
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444
{
	ssize_t error;
	void *kvalue = NULL;
445
	void *vvalue = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449 450 451 452 453 454 455 456
	char kname[XATTR_NAME_MAX + 1];

	error = strncpy_from_user(kname, name, sizeof(kname));
	if (error == 0 || error == sizeof(kname))
		error = -ERANGE;
	if (error < 0)
		return error;

	if (size) {
		if (size > XATTR_SIZE_MAX)
			size = XATTR_SIZE_MAX;
457 458 459 460 461 462 463
		kvalue = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
		if (!kvalue) {
			vvalue = vmalloc(size);
			if (!vvalue)
				return -ENOMEM;
			kvalue = vvalue;
		}
Linus Torvalds's avatar
Linus Torvalds committed
464 465
	}

466
	error = vfs_getxattr(d, kname, kvalue, size);
467
	if (error > 0) {
468 469 470
		if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
		    (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
			posix_acl_fix_xattr_to_user(kvalue, size);
471 472 473 474 475 476
		if (size && copy_to_user(value, kvalue, error))
			error = -EFAULT;
	} else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
		/* The file system tried to returned a value bigger
		   than XATTR_SIZE_MAX bytes. Not possible. */
		error = -E2BIG;
Linus Torvalds's avatar
Linus Torvalds committed
477
	}
478 479 480 481
	if (vvalue)
		vfree(vvalue);
	else
		kfree(kvalue);
Linus Torvalds's avatar
Linus Torvalds committed
482 483 484
	return error;
}

485 486
SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
		const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
487
{
488
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
489
	ssize_t error;
490 491 492
	unsigned int lookup_flags = LOOKUP_FOLLOW;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
493 494
	if (error)
		return error;
495 496
	error = getxattr(path.dentry, name, value, size);
	path_put(&path);
497 498 499 500
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
501 502 503
	return error;
}

504 505
SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
		const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
506
{
507
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
508
	ssize_t error;
509 510 511
	unsigned int lookup_flags = 0;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
512 513
	if (error)
		return error;
514 515
	error = getxattr(path.dentry, name, value, size);
	path_put(&path);
516 517 518 519
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522
	return error;
}

523 524
SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
		void __user *, value, size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
525
{
526
	struct fd f = fdget(fd);
Linus Torvalds's avatar
Linus Torvalds committed
527 528
	ssize_t error = -EBADF;

529
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
530
		return error;
531
	audit_inode(NULL, f.file->f_path.dentry, 0);
532 533
	error = getxattr(f.file->f_path.dentry, name, value, size);
	fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537 538 539 540 541 542 543 544
	return error;
}

/*
 * Extended attribute LIST operations
 */
static ssize_t
listxattr(struct dentry *d, char __user *list, size_t size)
{
	ssize_t error;
	char *klist = NULL;
545
	char *vlist = NULL;	/* If non-NULL, we used vmalloc() */
Linus Torvalds's avatar
Linus Torvalds committed
546 547 548 549

	if (size) {
		if (size > XATTR_LIST_MAX)
			size = XATTR_LIST_MAX;
550
		klist = kmalloc(size, __GFP_NOWARN | GFP_KERNEL);
551 552 553 554 555 556
		if (!klist) {
			vlist = vmalloc(size);
			if (!vlist)
				return -ENOMEM;
			klist = vlist;
		}
Linus Torvalds's avatar
Linus Torvalds committed
557 558
	}

559
	error = vfs_listxattr(d, klist, size);
560 561 562 563 564 565 566
	if (error > 0) {
		if (size && copy_to_user(list, klist, error))
			error = -EFAULT;
	} else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
		/* The file system tried to returned a list bigger
		   than XATTR_LIST_MAX bytes. Not possible. */
		error = -E2BIG;
Linus Torvalds's avatar
Linus Torvalds committed
567
	}
568 569 570 571
	if (vlist)
		vfree(vlist);
	else
		kfree(klist);
Linus Torvalds's avatar
Linus Torvalds committed
572 573 574
	return error;
}

575 576
SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
		size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
577
{
578
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
579
	ssize_t error;
580 581 582
	unsigned int lookup_flags = LOOKUP_FOLLOW;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
583 584
	if (error)
		return error;
585 586
	error = listxattr(path.dentry, list, size);
	path_put(&path);
587 588 589 590
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
591 592 593
	return error;
}

594 595
SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
		size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
596
{
597
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
598
	ssize_t error;
599 600 601
	unsigned int lookup_flags = 0;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
602 603
	if (error)
		return error;
604 605
	error = listxattr(path.dentry, list, size);
	path_put(&path);
606 607 608 609
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
610 611 612
	return error;
}

613
SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
Linus Torvalds's avatar
Linus Torvalds committed
614
{
615
	struct fd f = fdget(fd);
Linus Torvalds's avatar
Linus Torvalds committed
616 617
	ssize_t error = -EBADF;

618
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
619
		return error;
620
	audit_inode(NULL, f.file->f_path.dentry, 0);
621 622
	error = listxattr(f.file->f_path.dentry, list, size);
	fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
623 624 625 626 627 628 629
	return error;
}

/*
 * Extended attribute REMOVE operations
 */
static long
630
removexattr(struct dentry *d, const char __user *name)
Linus Torvalds's avatar
Linus Torvalds committed
631 632 633 634 635 636 637 638 639 640
{
	int error;
	char kname[XATTR_NAME_MAX + 1];

	error = strncpy_from_user(kname, name, sizeof(kname));
	if (error == 0 || error == sizeof(kname))
		error = -ERANGE;
	if (error < 0)
		return error;

641
	return vfs_removexattr(d, kname);
Linus Torvalds's avatar
Linus Torvalds committed
642 643
}

644 645
SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
		const char __user *, name)
Linus Torvalds's avatar
Linus Torvalds committed
646
{
647
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
648
	int error;
649 650 651
	unsigned int lookup_flags = LOOKUP_FOLLOW;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
652 653
	if (error)
		return error;
654
	error = mnt_want_write(path.mnt);
655
	if (!error) {
656 657
		error = removexattr(path.dentry, name);
		mnt_drop_write(path.mnt);
658
	}
659
	path_put(&path);
660 661 662 663
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666
	return error;
}

667 668
SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
		const char __user *, name)
Linus Torvalds's avatar
Linus Torvalds committed
669
{
670
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
671
	int error;
672 673 674
	unsigned int lookup_flags = 0;
retry:
	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
Linus Torvalds's avatar
Linus Torvalds committed
675 676
	if (error)
		return error;
677
	error = mnt_want_write(path.mnt);
678
	if (!error) {
679 680
		error = removexattr(path.dentry, name);
		mnt_drop_write(path.mnt);
681
	}
682
	path_put(&path);
683 684 685 686
	if (retry_estale(error, lookup_flags)) {
		lookup_flags |= LOOKUP_REVAL;
		goto retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
687 688 689
	return error;
}

690
SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
Linus Torvalds's avatar
Linus Torvalds committed
691
{
692
	struct fd f = fdget(fd);
693
	struct dentry *dentry;
Linus Torvalds's avatar
Linus Torvalds committed
694 695
	int error = -EBADF;

696
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
697
		return error;
698
	dentry = f.file->f_path.dentry;
699
	audit_inode(NULL, dentry, 0);
700
	error = mnt_want_write_file(f.file);
701 702
	if (!error) {
		error = removexattr(dentry, name);
703
		mnt_drop_write_file(f.file);
704
	}
705
	fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
	return error;
}


static const char *
strcmp_prefix(const char *a, const char *a_prefix)
{
	while (*a_prefix && *a == *a_prefix) {
		a++;
		a_prefix++;
	}
	return *a_prefix ? NULL : a;
}

/*
 * In order to implement different sets of xattr operations for each xattr
 * prefix with the generic xattr API, a filesystem should create a
 * null-terminated array of struct xattr_handler (one for each prefix) and
 * hang a pointer to it off of the s_xattr field of the superblock.
 *
 * The generic_fooxattr() functions will use this list to dispatch xattr
 * operations to the correct xattr_handler.
 */
#define for_each_xattr_handler(handlers, handler)		\
		for ((handler) = *(handlers)++;			\
			(handler) != NULL;			\
			(handler) = *(handlers)++)

/*
 * Find the xattr_handler with the matching prefix.
 */
737 738
static const struct xattr_handler *
xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
Linus Torvalds's avatar
Linus Torvalds committed
739
{
740
	const struct xattr_handler *handler;
Linus Torvalds's avatar
Linus Torvalds committed
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760

	if (!*name)
		return NULL;

	for_each_xattr_handler(handlers, handler) {
		const char *n = strcmp_prefix(*name, handler->prefix);
		if (n) {
			*name = n;
			break;
		}
	}
	return handler;
}

/*
 * Find the handler for the prefix and dispatch its get() operation.
 */
ssize_t
generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
{
761
	const struct xattr_handler *handler;
Linus Torvalds's avatar
Linus Torvalds committed
762

763
	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds's avatar
Linus Torvalds committed
764 765
	if (!handler)
		return -EOPNOTSUPP;
766
	return handler->get(dentry, name, buffer, size, handler->flags);
Linus Torvalds's avatar
Linus Torvalds committed
767 768 769 770 771 772 773 774 775
}

/*
 * Combine the results of the list() operation from every xattr_handler in the
 * list.
 */
ssize_t
generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
{
776
	const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
Linus Torvalds's avatar
Linus Torvalds committed
777 778 779
	unsigned int size = 0;

	if (!buffer) {
780 781 782 783
		for_each_xattr_handler(handlers, handler) {
			size += handler->list(dentry, NULL, 0, NULL, 0,
					      handler->flags);
		}
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787
	} else {
		char *buf = buffer;

		for_each_xattr_handler(handlers, handler) {
788 789
			size = handler->list(dentry, buf, buffer_size,
					     NULL, 0, handler->flags);
Linus Torvalds's avatar
Linus Torvalds committed
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
			if (size > buffer_size)
				return -ERANGE;
			buf += size;
			buffer_size -= size;
		}
		size = buf - buffer;
	}
	return size;
}

/*
 * Find the handler for the prefix and dispatch its set() operation.
 */
int
generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
{
806
	const struct xattr_handler *handler;
Linus Torvalds's avatar
Linus Torvalds committed
807 808 809

	if (size == 0)
		value = "";  /* empty EA, do not remove */
810
	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds's avatar
Linus Torvalds committed
811 812
	if (!handler)
		return -EOPNOTSUPP;
813
	return handler->set(dentry, name, value, size, flags, handler->flags);
Linus Torvalds's avatar
Linus Torvalds committed
814 815 816 817 818 819 820 821 822
}

/*
 * Find the handler for the prefix and dispatch its set() operation to remove
 * any associated extended attribute.
 */
int
generic_removexattr(struct dentry *dentry, const char *name)
{
823
	const struct xattr_handler *handler;
Linus Torvalds's avatar
Linus Torvalds committed
824

825
	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds's avatar
Linus Torvalds committed
826 827
	if (!handler)
		return -EOPNOTSUPP;
828 829
	return handler->set(dentry, name, NULL, 0,
			    XATTR_REPLACE, handler->flags);
Linus Torvalds's avatar
Linus Torvalds committed
830 831 832 833 834 835
}

EXPORT_SYMBOL(generic_getxattr);
EXPORT_SYMBOL(generic_listxattr);
EXPORT_SYMBOL(generic_setxattr);
EXPORT_SYMBOL(generic_removexattr);
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889

/*
 * Allocate new xattr and copy in the value; but leave the name to callers.
 */
struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
{
	struct simple_xattr *new_xattr;
	size_t len;

	/* wrap around? */
	len = sizeof(*new_xattr) + size;
	if (len <= sizeof(*new_xattr))
		return NULL;

	new_xattr = kmalloc(len, GFP_KERNEL);
	if (!new_xattr)
		return NULL;

	new_xattr->size = size;
	memcpy(new_xattr->value, value, size);
	return new_xattr;
}

/*
 * xattr GET operation for in-memory/pseudo filesystems
 */
int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
		     void *buffer, size_t size)
{
	struct simple_xattr *xattr;
	int ret = -ENODATA;

	spin_lock(&xattrs->lock);
	list_for_each_entry(xattr, &xattrs->head, list) {
		if (strcmp(name, xattr->name))
			continue;

		ret = xattr->size;
		if (buffer) {
			if (size < xattr->size)
				ret = -ERANGE;
			else
				memcpy(buffer, xattr->value, xattr->size);
		}
		break;
	}
	spin_unlock(&xattrs->lock);
	return ret;
}

static int __simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
			      const void *value, size_t size, int flags)
{
	struct simple_xattr *xattr;
890
	struct simple_xattr *new_xattr = NULL;
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
	int err = 0;

	/* value == NULL means remove */
	if (value) {
		new_xattr = simple_xattr_alloc(value, size);
		if (!new_xattr)
			return -ENOMEM;

		new_xattr->name = kstrdup(name, GFP_KERNEL);
		if (!new_xattr->name) {
			kfree(new_xattr);
			return -ENOMEM;
		}
	}

	spin_lock(&xattrs->lock);
	list_for_each_entry(xattr, &xattrs->head, list) {
		if (!strcmp(name, xattr->name)) {
			if (flags & XATTR_CREATE) {
				xattr = new_xattr;
				err = -EEXIST;
			} else if (new_xattr) {
				list_replace(&xattr->list, &new_xattr->list);
			} else {
				list_del(&xattr->list);
			}
			goto out;
		}
	}
	if (flags & XATTR_REPLACE) {
		xattr = new_xattr;
		err = -ENODATA;
	} else {
		list_add(&new_xattr->list, &xattrs->head);
		xattr = NULL;
	}
out:
	spin_unlock(&xattrs->lock);
	if (xattr) {
		kfree(xattr->name);
		kfree(xattr);
	}
	return err;

}

937 938 939 940 941 942 943 944 945 946 947 948 949
/**
 * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
 * @xattrs: target simple_xattr list
 * @name: name of the new extended attribute
 * @value: value of the new xattr. If %NULL, will remove the attribute
 * @size: size of the new xattr
 * @flags: %XATTR_{CREATE|REPLACE}
 *
 * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
 * with -EEXIST.  If %XATTR_REPLACE is set, the xattr should exist;
 * otherwise, fails with -ENODATA.
 *
 * Returns 0 on success, -errno on failure.
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
 */
int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
		     const void *value, size_t size, int flags)
{
	if (size == 0)
		value = ""; /* empty EA, do not remove */
	return __simple_xattr_set(xattrs, name, value, size, flags);
}

/*
 * xattr REMOVE operation for in-memory/pseudo filesystems
 */
int simple_xattr_remove(struct simple_xattrs *xattrs, const char *name)
{
	return __simple_xattr_set(xattrs, name, NULL, 0, XATTR_REPLACE);
}

static bool xattr_is_trusted(const char *name)
{
	return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
}

/*
 * xattr LIST operation for in-memory/pseudo filesystems
 */
ssize_t simple_xattr_list(struct simple_xattrs *xattrs, char *buffer,
			  size_t size)
{
	bool trusted = capable(CAP_SYS_ADMIN);
	struct simple_xattr *xattr;
	size_t used = 0;

	spin_lock(&xattrs->lock);
	list_for_each_entry(xattr, &xattrs->head, list) {
		size_t len;

		/* skip "trusted." attributes for unprivileged callers */
		if (!trusted && xattr_is_trusted(xattr->name))
			continue;

		len = strlen(xattr->name) + 1;
		used += len;
		if (buffer) {
			if (size < used) {
				used = -ERANGE;
				break;
			}
			memcpy(buffer, xattr->name, len);
			buffer += len;
		}
	}
	spin_unlock(&xattrs->lock);

	return used;
}

1006 1007 1008
/*
 * Adds an extended attribute to the list
 */
1009 1010 1011 1012 1013 1014 1015
void simple_xattr_list_add(struct simple_xattrs *xattrs,
			   struct simple_xattr *new_xattr)
{
	spin_lock(&xattrs->lock);
	list_add(&new_xattr->list, &xattrs->head);
	spin_unlock(&xattrs->lock);
}