xref: /openbmc/linux/fs/xattr.c (revision 1fa6ac37) 
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/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_IMMUTABLE(inode) || IS_APPEND(inode))
37 			return -EPERM;
38 	}
39 
40 	/*
41 	 * No restriction for security.* and system.* from the VFS.  Decision
42 	 * on these is left to the underlying filesystem / security module.
43 	 */
44 	if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
45 	    !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
46 		return 0;
47 
48 	/*
49 	 * The trusted.* namespace can only be accessed by a privileged user.
50 	 */
51 	if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
52 		return (capable(CAP_SYS_ADMIN) ? 0 : -EPERM);
53 
54 	/* In user.* namespace, only regular files and directories can have
55 	 * extended attributes. For sticky directories, only the owner and
56 	 * privileged user can write attributes.
57 	 */
58 	if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
59 		if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
60 			return -EPERM;
61 		if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
62 		    (mask & MAY_WRITE) && !is_owner_or_cap(inode))
63 			return -EPERM;
64 	}
65 
66 	return inode_permission(inode, mask);
67 }
68 
69 /**
70  *  __vfs_setxattr_noperm - perform setxattr operation without performing
71  *  permission checks.
72  *
73  *  @dentry - object to perform setxattr on
74  *  @name - xattr name to set
75  *  @value - value to set @name to
76  *  @size - size of @value
77  *  @flags - flags to pass into filesystem operations
78  *
79  *  returns the result of the internal setxattr or setsecurity operations.
80  *
81  *  This function requires the caller to lock the inode's i_mutex before it
82  *  is executed. It also assumes that the caller will make the appropriate
83  *  permission checks.
84  */
85 int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
86 		const void *value, size_t size, int flags)
87 {
88 	struct inode *inode = dentry->d_inode;
89 	int error = -EOPNOTSUPP;
90 
91 	if (inode->i_op->setxattr) {
92 		error = inode->i_op->setxattr(dentry, name, value, size, flags);
93 		if (!error) {
94 			fsnotify_xattr(dentry);
95 			security_inode_post_setxattr(dentry, name, value,
96 						     size, flags);
97 		}
98 	} else if (!strncmp(name, XATTR_SECURITY_PREFIX,
99 				XATTR_SECURITY_PREFIX_LEN)) {
100 		const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
101 		error = security_inode_setsecurity(inode, suffix, value,
102 						   size, flags);
103 		if (!error)
104 			fsnotify_xattr(dentry);
105 	}
106 
107 	return error;
108 }
109 
110 
111 int
112 vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
113 		size_t size, int flags)
114 {
115 	struct inode *inode = dentry->d_inode;
116 	int error;
117 
118 	error = xattr_permission(inode, name, MAY_WRITE);
119 	if (error)
120 		return error;
121 
122 	mutex_lock(&inode->i_mutex);
123 	error = security_inode_setxattr(dentry, name, value, size, flags);
124 	if (error)
125 		goto out;
126 
127 	error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
128 
129 out:
130 	mutex_unlock(&inode->i_mutex);
131 	return error;
132 }
133 EXPORT_SYMBOL_GPL(vfs_setxattr);
134 
135 ssize_t
136 xattr_getsecurity(struct inode *inode, const char *name, void *value,
137 			size_t size)
138 {
139 	void *buffer = NULL;
140 	ssize_t len;
141 
142 	if (!value || !size) {
143 		len = security_inode_getsecurity(inode, name, &buffer, false);
144 		goto out_noalloc;
145 	}
146 
147 	len = security_inode_getsecurity(inode, name, &buffer, true);
148 	if (len < 0)
149 		return len;
150 	if (size < len) {
151 		len = -ERANGE;
152 		goto out;
153 	}
154 	memcpy(value, buffer, len);
155 out:
156 	security_release_secctx(buffer, len);
157 out_noalloc:
158 	return len;
159 }
160 EXPORT_SYMBOL_GPL(xattr_getsecurity);
161 
162 ssize_t
163 vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
164 {
165 	struct inode *inode = dentry->d_inode;
166 	int error;
167 
168 	error = xattr_permission(inode, name, MAY_READ);
169 	if (error)
170 		return error;
171 
172 	error = security_inode_getxattr(dentry, name);
173 	if (error)
174 		return error;
175 
176 	if (!strncmp(name, XATTR_SECURITY_PREFIX,
177 				XATTR_SECURITY_PREFIX_LEN)) {
178 		const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
179 		int ret = xattr_getsecurity(inode, suffix, value, size);
180 		/*
181 		 * Only overwrite the return value if a security module
182 		 * is actually active.
183 		 */
184 		if (ret == -EOPNOTSUPP)
185 			goto nolsm;
186 		return ret;
187 	}
188 nolsm:
189 	if (inode->i_op->getxattr)
190 		error = inode->i_op->getxattr(dentry, name, value, size);
191 	else
192 		error = -EOPNOTSUPP;
193 
194 	return error;
195 }
196 EXPORT_SYMBOL_GPL(vfs_getxattr);
197 
198 ssize_t
199 vfs_listxattr(struct dentry *d, char *list, size_t size)
200 {
201 	ssize_t error;
202 
203 	error = security_inode_listxattr(d);
204 	if (error)
205 		return error;
206 	error = -EOPNOTSUPP;
207 	if (d->d_inode->i_op->listxattr) {
208 		error = d->d_inode->i_op->listxattr(d, list, size);
209 	} else {
210 		error = security_inode_listsecurity(d->d_inode, list, size);
211 		if (size && error > size)
212 			error = -ERANGE;
213 	}
214 	return error;
215 }
216 EXPORT_SYMBOL_GPL(vfs_listxattr);
217 
218 int
219 vfs_removexattr(struct dentry *dentry, const char *name)
220 {
221 	struct inode *inode = dentry->d_inode;
222 	int error;
223 
224 	if (!inode->i_op->removexattr)
225 		return -EOPNOTSUPP;
226 
227 	error = xattr_permission(inode, name, MAY_WRITE);
228 	if (error)
229 		return error;
230 
231 	error = security_inode_removexattr(dentry, name);
232 	if (error)
233 		return error;
234 
235 	mutex_lock(&inode->i_mutex);
236 	error = inode->i_op->removexattr(dentry, name);
237 	mutex_unlock(&inode->i_mutex);
238 
239 	if (!error)
240 		fsnotify_xattr(dentry);
241 	return error;
242 }
243 EXPORT_SYMBOL_GPL(vfs_removexattr);
244 
245 
246 /*
247  * Extended attribute SET operations
248  */
249 static long
250 setxattr(struct dentry *d, const char __user *name, const void __user *value,
251 	 size_t size, int flags)
252 {
253 	int error;
254 	void *kvalue = NULL;
255 	char kname[XATTR_NAME_MAX + 1];
256 
257 	if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
258 		return -EINVAL;
259 
260 	error = strncpy_from_user(kname, name, sizeof(kname));
261 	if (error == 0 || error == sizeof(kname))
262 		error = -ERANGE;
263 	if (error < 0)
264 		return error;
265 
266 	if (size) {
267 		if (size > XATTR_SIZE_MAX)
268 			return -E2BIG;
269 		kvalue = memdup_user(value, size);
270 		if (IS_ERR(kvalue))
271 			return PTR_ERR(kvalue);
272 	}
273 
274 	error = vfs_setxattr(d, kname, kvalue, size, flags);
275 	kfree(kvalue);
276 	return error;
277 }
278 
279 SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
280 		const char __user *, name, const void __user *, value,
281 		size_t, size, int, flags)
282 {
283 	struct path path;
284 	int error;
285 
286 	error = user_path(pathname, &path);
287 	if (error)
288 		return error;
289 	error = mnt_want_write(path.mnt);
290 	if (!error) {
291 		error = setxattr(path.dentry, name, value, size, flags);
292 		mnt_drop_write(path.mnt);
293 	}
294 	path_put(&path);
295 	return error;
296 }
297 
298 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
299 		const char __user *, name, const void __user *, value,
300 		size_t, size, int, flags)
301 {
302 	struct path path;
303 	int error;
304 
305 	error = user_lpath(pathname, &path);
306 	if (error)
307 		return error;
308 	error = mnt_want_write(path.mnt);
309 	if (!error) {
310 		error = setxattr(path.dentry, name, value, size, flags);
311 		mnt_drop_write(path.mnt);
312 	}
313 	path_put(&path);
314 	return error;
315 }
316 
317 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
318 		const void __user *,value, size_t, size, int, flags)
319 {
320 	struct file *f;
321 	struct dentry *dentry;
322 	int error = -EBADF;
323 
324 	f = fget(fd);
325 	if (!f)
326 		return error;
327 	dentry = f->f_path.dentry;
328 	audit_inode(NULL, dentry);
329 	error = mnt_want_write_file(f);
330 	if (!error) {
331 		error = setxattr(dentry, name, value, size, flags);
332 		mnt_drop_write(f->f_path.mnt);
333 	}
334 	fput(f);
335 	return error;
336 }
337 
338 /*
339  * Extended attribute GET operations
340  */
341 static ssize_t
342 getxattr(struct dentry *d, const char __user *name, void __user *value,
343 	 size_t size)
344 {
345 	ssize_t error;
346 	void *kvalue = NULL;
347 	char kname[XATTR_NAME_MAX + 1];
348 
349 	error = strncpy_from_user(kname, name, sizeof(kname));
350 	if (error == 0 || error == sizeof(kname))
351 		error = -ERANGE;
352 	if (error < 0)
353 		return error;
354 
355 	if (size) {
356 		if (size > XATTR_SIZE_MAX)
357 			size = XATTR_SIZE_MAX;
358 		kvalue = kzalloc(size, GFP_KERNEL);
359 		if (!kvalue)
360 			return -ENOMEM;
361 	}
362 
363 	error = vfs_getxattr(d, kname, kvalue, size);
364 	if (error > 0) {
365 		if (size && copy_to_user(value, kvalue, error))
366 			error = -EFAULT;
367 	} else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
368 		/* The file system tried to returned a value bigger
369 		   than XATTR_SIZE_MAX bytes. Not possible. */
370 		error = -E2BIG;
371 	}
372 	kfree(kvalue);
373 	return error;
374 }
375 
376 SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
377 		const char __user *, name, void __user *, value, size_t, size)
378 {
379 	struct path path;
380 	ssize_t error;
381 
382 	error = user_path(pathname, &path);
383 	if (error)
384 		return error;
385 	error = getxattr(path.dentry, name, value, size);
386 	path_put(&path);
387 	return error;
388 }
389 
390 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
391 		const char __user *, name, void __user *, value, size_t, size)
392 {
393 	struct path path;
394 	ssize_t error;
395 
396 	error = user_lpath(pathname, &path);
397 	if (error)
398 		return error;
399 	error = getxattr(path.dentry, name, value, size);
400 	path_put(&path);
401 	return error;
402 }
403 
404 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
405 		void __user *, value, size_t, size)
406 {
407 	struct file *f;
408 	ssize_t error = -EBADF;
409 
410 	f = fget(fd);
411 	if (!f)
412 		return error;
413 	audit_inode(NULL, f->f_path.dentry);
414 	error = getxattr(f->f_path.dentry, name, value, size);
415 	fput(f);
416 	return error;
417 }
418 
419 /*
420  * Extended attribute LIST operations
421  */
422 static ssize_t
423 listxattr(struct dentry *d, char __user *list, size_t size)
424 {
425 	ssize_t error;
426 	char *klist = NULL;
427 
428 	if (size) {
429 		if (size > XATTR_LIST_MAX)
430 			size = XATTR_LIST_MAX;
431 		klist = kmalloc(size, GFP_KERNEL);
432 		if (!klist)
433 			return -ENOMEM;
434 	}
435 
436 	error = vfs_listxattr(d, klist, size);
437 	if (error > 0) {
438 		if (size && copy_to_user(list, klist, error))
439 			error = -EFAULT;
440 	} else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
441 		/* The file system tried to returned a list bigger
442 		   than XATTR_LIST_MAX bytes. Not possible. */
443 		error = -E2BIG;
444 	}
445 	kfree(klist);
446 	return error;
447 }
448 
449 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
450 		size_t, size)
451 {
452 	struct path path;
453 	ssize_t error;
454 
455 	error = user_path(pathname, &path);
456 	if (error)
457 		return error;
458 	error = listxattr(path.dentry, list, size);
459 	path_put(&path);
460 	return error;
461 }
462 
463 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
464 		size_t, size)
465 {
466 	struct path path;
467 	ssize_t error;
468 
469 	error = user_lpath(pathname, &path);
470 	if (error)
471 		return error;
472 	error = listxattr(path.dentry, list, size);
473 	path_put(&path);
474 	return error;
475 }
476 
477 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
478 {
479 	struct file *f;
480 	ssize_t error = -EBADF;
481 
482 	f = fget(fd);
483 	if (!f)
484 		return error;
485 	audit_inode(NULL, f->f_path.dentry);
486 	error = listxattr(f->f_path.dentry, list, size);
487 	fput(f);
488 	return error;
489 }
490 
491 /*
492  * Extended attribute REMOVE operations
493  */
494 static long
495 removexattr(struct dentry *d, const char __user *name)
496 {
497 	int error;
498 	char kname[XATTR_NAME_MAX + 1];
499 
500 	error = strncpy_from_user(kname, name, sizeof(kname));
501 	if (error == 0 || error == sizeof(kname))
502 		error = -ERANGE;
503 	if (error < 0)
504 		return error;
505 
506 	return vfs_removexattr(d, kname);
507 }
508 
509 SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
510 		const char __user *, name)
511 {
512 	struct path path;
513 	int error;
514 
515 	error = user_path(pathname, &path);
516 	if (error)
517 		return error;
518 	error = mnt_want_write(path.mnt);
519 	if (!error) {
520 		error = removexattr(path.dentry, name);
521 		mnt_drop_write(path.mnt);
522 	}
523 	path_put(&path);
524 	return error;
525 }
526 
527 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
528 		const char __user *, name)
529 {
530 	struct path path;
531 	int error;
532 
533 	error = user_lpath(pathname, &path);
534 	if (error)
535 		return error;
536 	error = mnt_want_write(path.mnt);
537 	if (!error) {
538 		error = removexattr(path.dentry, name);
539 		mnt_drop_write(path.mnt);
540 	}
541 	path_put(&path);
542 	return error;
543 }
544 
545 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
546 {
547 	struct file *f;
548 	struct dentry *dentry;
549 	int error = -EBADF;
550 
551 	f = fget(fd);
552 	if (!f)
553 		return error;
554 	dentry = f->f_path.dentry;
555 	audit_inode(NULL, dentry);
556 	error = mnt_want_write_file(f);
557 	if (!error) {
558 		error = removexattr(dentry, name);
559 		mnt_drop_write(f->f_path.mnt);
560 	}
561 	fput(f);
562 	return error;
563 }
564 
565 
566 static const char *
567 strcmp_prefix(const char *a, const char *a_prefix)
568 {
569 	while (*a_prefix && *a == *a_prefix) {
570 		a++;
571 		a_prefix++;
572 	}
573 	return *a_prefix ? NULL : a;
574 }
575 
576 /*
577  * In order to implement different sets of xattr operations for each xattr
578  * prefix with the generic xattr API, a filesystem should create a
579  * null-terminated array of struct xattr_handler (one for each prefix) and
580  * hang a pointer to it off of the s_xattr field of the superblock.
581  *
582  * The generic_fooxattr() functions will use this list to dispatch xattr
583  * operations to the correct xattr_handler.
584  */
585 #define for_each_xattr_handler(handlers, handler)		\
586 		for ((handler) = *(handlers)++;			\
587 			(handler) != NULL;			\
588 			(handler) = *(handlers)++)
589 
590 /*
591  * Find the xattr_handler with the matching prefix.
592  */
593 static const struct xattr_handler *
594 xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
595 {
596 	const struct xattr_handler *handler;
597 
598 	if (!*name)
599 		return NULL;
600 
601 	for_each_xattr_handler(handlers, handler) {
602 		const char *n = strcmp_prefix(*name, handler->prefix);
603 		if (n) {
604 			*name = n;
605 			break;
606 		}
607 	}
608 	return handler;
609 }
610 
611 /*
612  * Find the handler for the prefix and dispatch its get() operation.
613  */
614 ssize_t
615 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
616 {
617 	const struct xattr_handler *handler;
618 
619 	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
620 	if (!handler)
621 		return -EOPNOTSUPP;
622 	return handler->get(dentry, name, buffer, size, handler->flags);
623 }
624 
625 /*
626  * Combine the results of the list() operation from every xattr_handler in the
627  * list.
628  */
629 ssize_t
630 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
631 {
632 	const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
633 	unsigned int size = 0;
634 
635 	if (!buffer) {
636 		for_each_xattr_handler(handlers, handler) {
637 			size += handler->list(dentry, NULL, 0, NULL, 0,
638 					      handler->flags);
639 		}
640 	} else {
641 		char *buf = buffer;
642 
643 		for_each_xattr_handler(handlers, handler) {
644 			size = handler->list(dentry, buf, buffer_size,
645 					     NULL, 0, handler->flags);
646 			if (size > buffer_size)
647 				return -ERANGE;
648 			buf += size;
649 			buffer_size -= size;
650 		}
651 		size = buf - buffer;
652 	}
653 	return size;
654 }
655 
656 /*
657  * Find the handler for the prefix and dispatch its set() operation.
658  */
659 int
660 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
661 {
662 	const struct xattr_handler *handler;
663 
664 	if (size == 0)
665 		value = "";  /* empty EA, do not remove */
666 	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
667 	if (!handler)
668 		return -EOPNOTSUPP;
669 	return handler->set(dentry, name, value, size, 0, handler->flags);
670 }
671 
672 /*
673  * Find the handler for the prefix and dispatch its set() operation to remove
674  * any associated extended attribute.
675  */
676 int
677 generic_removexattr(struct dentry *dentry, const char *name)
678 {
679 	const struct xattr_handler *handler;
680 
681 	handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
682 	if (!handler)
683 		return -EOPNOTSUPP;
684 	return handler->set(dentry, name, NULL, 0,
685 			    XATTR_REPLACE, handler->flags);
686 }
687 
688 EXPORT_SYMBOL(generic_getxattr);
689 EXPORT_SYMBOL(generic_listxattr);
690 EXPORT_SYMBOL(generic_setxattr);
691 EXPORT_SYMBOL(generic_removexattr);
692