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