Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : File: fs/xattr.c
4 : :
5 : : Extended attribute handling.
6 : :
7 : : Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
8 : : Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
9 : : Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
10 : : */
11 : : #include <linux/fs.h>
12 : : #include <linux/slab.h>
13 : : #include <linux/file.h>
14 : : #include <linux/xattr.h>
15 : : #include <linux/mount.h>
16 : : #include <linux/namei.h>
17 : : #include <linux/security.h>
18 : : #include <linux/evm.h>
19 : : #include <linux/syscalls.h>
20 : : #include <linux/export.h>
21 : : #include <linux/fsnotify.h>
22 : : #include <linux/audit.h>
23 : : #include <linux/vmalloc.h>
24 : : #include <linux/posix_acl_xattr.h>
25 : :
26 : : #include <linux/uaccess.h>
27 : :
28 : : static const char *
29 : 151473 : strcmp_prefix(const char *a, const char *a_prefix)
30 : : {
31 [ + + + + ]: 510132 : while (*a_prefix && *a == *a_prefix) {
32 : 358659 : a++;
33 : 358659 : a_prefix++;
34 : : }
35 [ + + ]: 151473 : return *a_prefix ? NULL : a;
36 : : }
37 : :
38 : : /*
39 : : * In order to implement different sets of xattr operations for each xattr
40 : : * prefix, a filesystem should create a null-terminated array of struct
41 : : * xattr_handler (one for each prefix) and hang a pointer to it off of the
42 : : * s_xattr field of the superblock.
43 : : */
44 : : #define for_each_xattr_handler(handlers, handler) \
45 : : if (handlers) \
46 : : for ((handler) = *(handlers)++; \
47 : : (handler) != NULL; \
48 : : (handler) = *(handlers)++)
49 : :
50 : : /*
51 : : * Find the xattr_handler with the matching prefix.
52 : : */
53 : : static const struct xattr_handler *
54 : 32697 : xattr_resolve_name(struct inode *inode, const char **name)
55 : : {
56 : 32697 : const struct xattr_handler **handlers = inode->i_sb->s_xattr;
57 : 32697 : const struct xattr_handler *handler;
58 : :
59 [ + + ]: 32697 : if (!(inode->i_opflags & IOP_XATTR)) {
60 [ + - ]: 63 : if (unlikely(is_bad_inode(inode)))
61 : : return ERR_PTR(-EIO);
62 : 63 : return ERR_PTR(-EOPNOTSUPP);
63 : : }
64 [ + - + + ]: 151494 : for_each_xattr_handler(handlers, handler) {
65 : 151473 : const char *n;
66 : :
67 [ + + ]: 215439 : n = strcmp_prefix(*name, xattr_prefix(handler));
68 [ + - ]: 32613 : if (n) {
69 [ - + ]: 32613 : if (!handler->prefix ^ !*n) {
70 [ # # ]: 0 : if (*n)
71 : 0 : continue;
72 : : return ERR_PTR(-EINVAL);
73 : : }
74 : 32613 : *name = n;
75 : 32613 : return handler;
76 : : }
77 : : }
78 : : return ERR_PTR(-EOPNOTSUPP);
79 : : }
80 : :
81 : : /*
82 : : * Check permissions for extended attribute access. This is a bit complicated
83 : : * because different namespaces have very different rules.
84 : : */
85 : : static int
86 : 693 : xattr_permission(struct inode *inode, const char *name, int mask)
87 : : {
88 : : /*
89 : : * We can never set or remove an extended attribute on a read-only
90 : : * filesystem or on an immutable / append-only inode.
91 : : */
92 [ + - ]: 693 : if (mask & MAY_WRITE) {
93 [ + - ]: 693 : if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
94 : : return -EPERM;
95 : : /*
96 : : * Updating an xattr will likely cause i_uid and i_gid
97 : : * to be writen back improperly if their true value is
98 : : * unknown to the vfs.
99 : : */
100 [ + - + - ]: 1386 : if (HAS_UNMAPPED_ID(inode))
101 : : return -EPERM;
102 : : }
103 : :
104 : : /*
105 : : * No restriction for security.* and system.* from the VFS. Decision
106 : : * on these is left to the underlying filesystem / security module.
107 : : */
108 [ + - ]: 693 : if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
109 [ + + ]: 693 : !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
110 : : return 0;
111 : :
112 : : /*
113 : : * The trusted.* namespace can only be accessed by privileged users.
114 : : */
115 [ + + ]: 609 : if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
116 [ - + ]: 588 : if (!capable(CAP_SYS_ADMIN))
117 [ # # ]: 0 : return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
118 : : return 0;
119 : : }
120 : :
121 : : /*
122 : : * In the user.* namespace, only regular files and directories can have
123 : : * extended attributes. For sticky directories, only the owner and
124 : : * privileged users can write attributes.
125 : : */
126 [ + - ]: 21 : if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
127 [ - + ]: 21 : if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
128 [ # # ]: 0 : return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
129 [ - + - - ]: 21 : if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
130 [ # # ]: 0 : (mask & MAY_WRITE) && !inode_owner_or_capable(inode))
131 : : return -EPERM;
132 : : }
133 : :
134 : 21 : return inode_permission(inode, mask);
135 : : }
136 : :
137 : : int
138 : 609 : __vfs_setxattr(struct dentry *dentry, struct inode *inode, const char *name,
139 : : const void *value, size_t size, int flags)
140 : : {
141 : 609 : const struct xattr_handler *handler;
142 : :
143 : 609 : handler = xattr_resolve_name(inode, &name);
144 [ + + ]: 609 : if (IS_ERR(handler))
145 : 21 : return PTR_ERR(handler);
146 [ + - ]: 588 : if (!handler->set)
147 : : return -EOPNOTSUPP;
148 [ - + ]: 588 : if (size == 0)
149 : 0 : value = ""; /* empty EA, do not remove */
150 : 588 : return handler->set(handler, dentry, inode, name, value, size, flags);
151 : : }
152 : : EXPORT_SYMBOL(__vfs_setxattr);
153 : :
154 : : /**
155 : : * __vfs_setxattr_noperm - perform setxattr operation without performing
156 : : * permission checks.
157 : : *
158 : : * @dentry - object to perform setxattr on
159 : : * @name - xattr name to set
160 : : * @value - value to set @name to
161 : : * @size - size of @value
162 : : * @flags - flags to pass into filesystem operations
163 : : *
164 : : * returns the result of the internal setxattr or setsecurity operations.
165 : : *
166 : : * This function requires the caller to lock the inode's i_mutex before it
167 : : * is executed. It also assumes that the caller will make the appropriate
168 : : * permission checks.
169 : : */
170 : 609 : int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
171 : : const void *value, size_t size, int flags)
172 : : {
173 : 609 : struct inode *inode = dentry->d_inode;
174 : 609 : int error = -EAGAIN;
175 : 609 : int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
176 : : XATTR_SECURITY_PREFIX_LEN);
177 : :
178 [ - + ]: 609 : if (issec)
179 : 0 : inode->i_flags &= ~S_NOSEC;
180 [ + - ]: 609 : if (inode->i_opflags & IOP_XATTR) {
181 : 609 : error = __vfs_setxattr(dentry, inode, name, value, size, flags);
182 [ + + ]: 609 : if (!error) {
183 : 588 : fsnotify_xattr(dentry);
184 : 588 : security_inode_post_setxattr(dentry, name, value,
185 : : size, flags);
186 : : }
187 : : } else {
188 [ # # ]: 0 : if (unlikely(is_bad_inode(inode)))
189 : : return -EIO;
190 : : }
191 [ - + ]: 609 : if (error == -EAGAIN) {
192 : 0 : error = -EOPNOTSUPP;
193 : :
194 [ # # ]: 0 : if (issec) {
195 : 0 : const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
196 : :
197 : 0 : error = security_inode_setsecurity(inode, suffix, value,
198 : : size, flags);
199 [ # # ]: 0 : if (!error)
200 : 0 : fsnotify_xattr(dentry);
201 : : }
202 : : }
203 : :
204 : : return error;
205 : : }
206 : :
207 : :
208 : : int
209 : 609 : vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
210 : : size_t size, int flags)
211 : : {
212 : 609 : struct inode *inode = dentry->d_inode;
213 : 609 : int error;
214 : :
215 : 609 : error = xattr_permission(inode, name, MAY_WRITE);
216 [ + - ]: 609 : if (error)
217 : : return error;
218 : :
219 : 609 : inode_lock(inode);
220 : 609 : error = security_inode_setxattr(dentry, name, value, size, flags);
221 [ - + ]: 609 : if (error)
222 : 0 : goto out;
223 : :
224 : 609 : error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
225 : :
226 : 609 : out:
227 : 609 : inode_unlock(inode);
228 : 609 : return error;
229 : : }
230 : : EXPORT_SYMBOL_GPL(vfs_setxattr);
231 : :
232 : : static ssize_t
233 : 0 : xattr_getsecurity(struct inode *inode, const char *name, void *value,
234 : : size_t size)
235 : : {
236 : 0 : void *buffer = NULL;
237 : 0 : ssize_t len;
238 : :
239 [ # # ]: 0 : if (!value || !size) {
240 : 0 : len = security_inode_getsecurity(inode, name, &buffer, false);
241 : 0 : goto out_noalloc;
242 : : }
243 : :
244 : 0 : len = security_inode_getsecurity(inode, name, &buffer, true);
245 [ # # ]: 0 : if (len < 0)
246 : : return len;
247 [ # # ]: 0 : if (size < len) {
248 : 0 : len = -ERANGE;
249 : 0 : goto out;
250 : : }
251 : 0 : memcpy(value, buffer, len);
252 : 0 : out:
253 : 0 : kfree(buffer);
254 : : out_noalloc:
255 : : return len;
256 : : }
257 : :
258 : : /*
259 : : * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
260 : : *
261 : : * Allocate memory, if not already allocated, or re-allocate correct size,
262 : : * before retrieving the extended attribute.
263 : : *
264 : : * Returns the result of alloc, if failed, or the getxattr operation.
265 : : */
266 : : ssize_t
267 : 0 : vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
268 : : size_t xattr_size, gfp_t flags)
269 : : {
270 : 0 : const struct xattr_handler *handler;
271 : 0 : struct inode *inode = dentry->d_inode;
272 : 0 : char *value = *xattr_value;
273 : 0 : int error;
274 : :
275 : 0 : error = xattr_permission(inode, name, MAY_READ);
276 [ # # ]: 0 : if (error)
277 : 0 : return error;
278 : :
279 : 0 : handler = xattr_resolve_name(inode, &name);
280 [ # # ]: 0 : if (IS_ERR(handler))
281 : 0 : return PTR_ERR(handler);
282 [ # # ]: 0 : if (!handler->get)
283 : : return -EOPNOTSUPP;
284 : 0 : error = handler->get(handler, dentry, inode, name, NULL, 0);
285 [ # # ]: 0 : if (error < 0)
286 : 0 : return error;
287 : :
288 [ # # # # ]: 0 : if (!value || (error > xattr_size)) {
289 : 0 : value = krealloc(*xattr_value, error + 1, flags);
290 [ # # ]: 0 : if (!value)
291 : : return -ENOMEM;
292 : 0 : memset(value, 0, error + 1);
293 : : }
294 : :
295 : 0 : error = handler->get(handler, dentry, inode, name, value, error);
296 : 0 : *xattr_value = value;
297 : 0 : return error;
298 : : }
299 : :
300 : : ssize_t
301 : 32004 : __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name,
302 : : void *value, size_t size)
303 : : {
304 : 32004 : const struct xattr_handler *handler;
305 : :
306 : 32004 : handler = xattr_resolve_name(inode, &name);
307 [ + + ]: 32004 : if (IS_ERR(handler))
308 : 63 : return PTR_ERR(handler);
309 [ + - ]: 31941 : if (!handler->get)
310 : : return -EOPNOTSUPP;
311 : 31941 : return handler->get(handler, dentry, inode, name, value, size);
312 : : }
313 : : EXPORT_SYMBOL(__vfs_getxattr);
314 : :
315 : : ssize_t
316 : 0 : vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
317 : : {
318 : 0 : struct inode *inode = dentry->d_inode;
319 : 0 : int error;
320 : :
321 : 0 : error = xattr_permission(inode, name, MAY_READ);
322 [ # # ]: 0 : if (error)
323 : 0 : return error;
324 : :
325 : 0 : error = security_inode_getxattr(dentry, name);
326 [ # # ]: 0 : if (error)
327 : 0 : return error;
328 : :
329 [ # # ]: 0 : if (!strncmp(name, XATTR_SECURITY_PREFIX,
330 : : XATTR_SECURITY_PREFIX_LEN)) {
331 : 0 : const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
332 : 0 : int ret = xattr_getsecurity(inode, suffix, value, size);
333 : : /*
334 : : * Only overwrite the return value if a security module
335 : : * is actually active.
336 : : */
337 [ # # ]: 0 : if (ret == -EOPNOTSUPP)
338 : 0 : goto nolsm;
339 : 0 : return ret;
340 : : }
341 : 0 : nolsm:
342 : 0 : return __vfs_getxattr(dentry, inode, name, value, size);
343 : : }
344 : : EXPORT_SYMBOL_GPL(vfs_getxattr);
345 : :
346 : : ssize_t
347 : 0 : vfs_listxattr(struct dentry *dentry, char *list, size_t size)
348 : : {
349 : 0 : struct inode *inode = d_inode(dentry);
350 : 0 : ssize_t error;
351 : :
352 : 0 : error = security_inode_listxattr(dentry);
353 [ # # ]: 0 : if (error)
354 : : return error;
355 [ # # # # ]: 0 : if (inode->i_op->listxattr && (inode->i_opflags & IOP_XATTR)) {
356 : 0 : error = inode->i_op->listxattr(dentry, list, size);
357 : : } else {
358 : 0 : error = security_inode_listsecurity(inode, list, size);
359 [ # # ]: 0 : if (size && error > size)
360 : 0 : error = -ERANGE;
361 : : }
362 : : return error;
363 : : }
364 : : EXPORT_SYMBOL_GPL(vfs_listxattr);
365 : :
366 : : int
367 : 84 : __vfs_removexattr(struct dentry *dentry, const char *name)
368 : : {
369 : 84 : struct inode *inode = d_inode(dentry);
370 : 84 : const struct xattr_handler *handler;
371 : :
372 : 84 : handler = xattr_resolve_name(inode, &name);
373 [ - + ]: 84 : if (IS_ERR(handler))
374 : 0 : return PTR_ERR(handler);
375 [ + - ]: 84 : if (!handler->set)
376 : : return -EOPNOTSUPP;
377 : 84 : return handler->set(handler, dentry, inode, name, NULL, 0, XATTR_REPLACE);
378 : : }
379 : : EXPORT_SYMBOL(__vfs_removexattr);
380 : :
381 : : int
382 : 84 : vfs_removexattr(struct dentry *dentry, const char *name)
383 : : {
384 : 84 : struct inode *inode = dentry->d_inode;
385 : 84 : int error;
386 : :
387 : 84 : error = xattr_permission(inode, name, MAY_WRITE);
388 [ + - ]: 84 : if (error)
389 : : return error;
390 : :
391 : 84 : inode_lock(inode);
392 : 84 : error = security_inode_removexattr(dentry, name);
393 [ - + ]: 84 : if (error)
394 : 0 : goto out;
395 : :
396 : 84 : error = __vfs_removexattr(dentry, name);
397 : :
398 [ - + ]: 84 : if (!error) {
399 : 84 : fsnotify_xattr(dentry);
400 : 84 : evm_inode_post_removexattr(dentry, name);
401 : : }
402 : :
403 : 0 : out:
404 : 84 : inode_unlock(inode);
405 : 84 : return error;
406 : : }
407 : : EXPORT_SYMBOL_GPL(vfs_removexattr);
408 : :
409 : :
410 : : /*
411 : : * Extended attribute SET operations
412 : : */
413 : : static long
414 : 609 : setxattr(struct dentry *d, const char __user *name, const void __user *value,
415 : : size_t size, int flags)
416 : : {
417 : 609 : int error;
418 : 609 : void *kvalue = NULL;
419 : 609 : char kname[XATTR_NAME_MAX + 1];
420 : :
421 [ + - ]: 609 : if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
422 : : return -EINVAL;
423 : :
424 : 609 : error = strncpy_from_user(kname, name, sizeof(kname));
425 [ + - ]: 609 : if (error == 0 || error == sizeof(kname))
426 : : error = -ERANGE;
427 [ - + ]: 609 : if (error < 0)
428 : 0 : return error;
429 : :
430 [ + - ]: 609 : if (size) {
431 [ + - ]: 609 : if (size > XATTR_SIZE_MAX)
432 : : return -E2BIG;
433 : 609 : kvalue = kvmalloc(size, GFP_KERNEL);
434 [ + - ]: 609 : if (!kvalue)
435 : : return -ENOMEM;
436 [ - + - + ]: 1218 : if (copy_from_user(kvalue, value, size)) {
437 : 0 : error = -EFAULT;
438 : 0 : goto out;
439 : : }
440 [ + - ]: 609 : if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
441 [ - + ]: 609 : (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
442 : 0 : posix_acl_fix_xattr_from_user(kvalue, size);
443 [ - + ]: 609 : else if (strcmp(kname, XATTR_NAME_CAPS) == 0) {
444 : 0 : error = cap_convert_nscap(d, &kvalue, size);
445 [ # # ]: 0 : if (error < 0)
446 : 0 : goto out;
447 : 0 : size = error;
448 : : }
449 : : }
450 : :
451 : 609 : error = vfs_setxattr(d, kname, kvalue, size, flags);
452 : 609 : out:
453 : 609 : kvfree(kvalue);
454 : :
455 : 609 : return error;
456 : : }
457 : :
458 : 588 : static int path_setxattr(const char __user *pathname,
459 : : const char __user *name, const void __user *value,
460 : : size_t size, int flags, unsigned int lookup_flags)
461 : : {
462 : 588 : struct path path;
463 : 588 : int error;
464 : 588 : retry:
465 : 588 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
466 [ - + ]: 588 : if (error)
467 : 0 : return error;
468 : 588 : error = mnt_want_write(path.mnt);
469 [ + - ]: 588 : if (!error) {
470 : 588 : error = setxattr(path.dentry, name, value, size, flags);
471 : 588 : mnt_drop_write(path.mnt);
472 : : }
473 : 588 : path_put(&path);
474 [ - + - + ]: 1176 : if (retry_estale(error, lookup_flags)) {
475 : 0 : lookup_flags |= LOOKUP_REVAL;
476 : 0 : goto retry;
477 : : }
478 : : return error;
479 : : }
480 : :
481 : 1176 : SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
482 : : const char __user *, name, const void __user *, value,
483 : : size_t, size, int, flags)
484 : : {
485 : 588 : return path_setxattr(pathname, name, value, size, flags, LOOKUP_FOLLOW);
486 : : }
487 : :
488 : 0 : SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
489 : : const char __user *, name, const void __user *, value,
490 : : size_t, size, int, flags)
491 : : {
492 : 0 : return path_setxattr(pathname, name, value, size, flags, 0);
493 : : }
494 : :
495 : 42 : SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
496 : : const void __user *,value, size_t, size, int, flags)
497 : : {
498 : 21 : struct fd f = fdget(fd);
499 : 21 : int error = -EBADF;
500 : :
501 [ + - ]: 21 : if (!f.file)
502 : : return error;
503 : 21 : audit_file(f.file);
504 : 21 : error = mnt_want_write_file(f.file);
505 [ + - ]: 21 : if (!error) {
506 : 21 : error = setxattr(f.file->f_path.dentry, name, value, size, flags);
507 : 21 : mnt_drop_write_file(f.file);
508 : : }
509 [ - + ]: 21 : fdput(f);
510 : 21 : return error;
511 : : }
512 : :
513 : : /*
514 : : * Extended attribute GET operations
515 : : */
516 : : static ssize_t
517 : 0 : getxattr(struct dentry *d, const char __user *name, void __user *value,
518 : : size_t size)
519 : : {
520 : 0 : ssize_t error;
521 : 0 : void *kvalue = NULL;
522 : 0 : char kname[XATTR_NAME_MAX + 1];
523 : :
524 : 0 : error = strncpy_from_user(kname, name, sizeof(kname));
525 [ # # ]: 0 : if (error == 0 || error == sizeof(kname))
526 : : error = -ERANGE;
527 [ # # ]: 0 : if (error < 0)
528 : 0 : return error;
529 : :
530 [ # # ]: 0 : if (size) {
531 : 0 : if (size > XATTR_SIZE_MAX)
532 : : size = XATTR_SIZE_MAX;
533 : 0 : kvalue = kvzalloc(size, GFP_KERNEL);
534 [ # # ]: 0 : if (!kvalue)
535 : : return -ENOMEM;
536 : : }
537 : :
538 : 0 : error = vfs_getxattr(d, kname, kvalue, size);
539 [ # # ]: 0 : if (error > 0) {
540 [ # # ]: 0 : if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
541 [ # # ]: 0 : (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
542 : 0 : posix_acl_fix_xattr_to_user(kvalue, error);
543 [ # # # # : 0 : if (size && copy_to_user(value, kvalue, error))
# # ]
544 : 0 : error = -EFAULT;
545 [ # # ]: 0 : } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
546 : : /* The file system tried to returned a value bigger
547 : : than XATTR_SIZE_MAX bytes. Not possible. */
548 : 0 : error = -E2BIG;
549 : : }
550 : :
551 : 0 : kvfree(kvalue);
552 : :
553 : 0 : return error;
554 : : }
555 : :
556 : 0 : static ssize_t path_getxattr(const char __user *pathname,
557 : : const char __user *name, void __user *value,
558 : : size_t size, unsigned int lookup_flags)
559 : : {
560 : 0 : struct path path;
561 : 0 : ssize_t error;
562 : 0 : retry:
563 : 0 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
564 [ # # ]: 0 : if (error)
565 : 0 : return error;
566 : 0 : error = getxattr(path.dentry, name, value, size);
567 : 0 : path_put(&path);
568 [ # # # # ]: 0 : if (retry_estale(error, lookup_flags)) {
569 : 0 : lookup_flags |= LOOKUP_REVAL;
570 : 0 : goto retry;
571 : : }
572 : : return error;
573 : : }
574 : :
575 : 0 : SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
576 : : const char __user *, name, void __user *, value, size_t, size)
577 : : {
578 : 0 : return path_getxattr(pathname, name, value, size, LOOKUP_FOLLOW);
579 : : }
580 : :
581 : 0 : SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
582 : : const char __user *, name, void __user *, value, size_t, size)
583 : : {
584 : 0 : return path_getxattr(pathname, name, value, size, 0);
585 : : }
586 : :
587 : 0 : SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
588 : : void __user *, value, size_t, size)
589 : : {
590 : 0 : struct fd f = fdget(fd);
591 : 0 : ssize_t error = -EBADF;
592 : :
593 [ # # ]: 0 : if (!f.file)
594 : : return error;
595 : 0 : audit_file(f.file);
596 : 0 : error = getxattr(f.file->f_path.dentry, name, value, size);
597 [ # # ]: 0 : fdput(f);
598 : : return error;
599 : : }
600 : :
601 : : /*
602 : : * Extended attribute LIST operations
603 : : */
604 : : static ssize_t
605 : 0 : listxattr(struct dentry *d, char __user *list, size_t size)
606 : : {
607 : 0 : ssize_t error;
608 : 0 : char *klist = NULL;
609 : :
610 [ # # ]: 0 : if (size) {
611 : 0 : if (size > XATTR_LIST_MAX)
612 : : size = XATTR_LIST_MAX;
613 : 0 : klist = kvmalloc(size, GFP_KERNEL);
614 [ # # ]: 0 : if (!klist)
615 : : return -ENOMEM;
616 : : }
617 : :
618 : 0 : error = vfs_listxattr(d, klist, size);
619 [ # # ]: 0 : if (error > 0) {
620 [ # # # # : 0 : if (size && copy_to_user(list, klist, error))
# # ]
621 : 0 : error = -EFAULT;
622 [ # # ]: 0 : } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
623 : : /* The file system tried to returned a list bigger
624 : : than XATTR_LIST_MAX bytes. Not possible. */
625 : 0 : error = -E2BIG;
626 : : }
627 : :
628 : 0 : kvfree(klist);
629 : :
630 : 0 : return error;
631 : : }
632 : :
633 : 0 : static ssize_t path_listxattr(const char __user *pathname, char __user *list,
634 : : size_t size, unsigned int lookup_flags)
635 : : {
636 : 0 : struct path path;
637 : 0 : ssize_t error;
638 : 0 : retry:
639 : 0 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
640 [ # # ]: 0 : if (error)
641 : 0 : return error;
642 : 0 : error = listxattr(path.dentry, list, size);
643 : 0 : path_put(&path);
644 [ # # # # ]: 0 : if (retry_estale(error, lookup_flags)) {
645 : 0 : lookup_flags |= LOOKUP_REVAL;
646 : 0 : goto retry;
647 : : }
648 : : return error;
649 : : }
650 : :
651 : 0 : SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
652 : : size_t, size)
653 : : {
654 : 0 : return path_listxattr(pathname, list, size, LOOKUP_FOLLOW);
655 : : }
656 : :
657 : 0 : SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
658 : : size_t, size)
659 : : {
660 : 0 : return path_listxattr(pathname, list, size, 0);
661 : : }
662 : :
663 : 0 : SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
664 : : {
665 : 0 : struct fd f = fdget(fd);
666 : 0 : ssize_t error = -EBADF;
667 : :
668 [ # # ]: 0 : if (!f.file)
669 : : return error;
670 : 0 : audit_file(f.file);
671 : 0 : error = listxattr(f.file->f_path.dentry, list, size);
672 [ # # ]: 0 : fdput(f);
673 : : return error;
674 : : }
675 : :
676 : : /*
677 : : * Extended attribute REMOVE operations
678 : : */
679 : : static long
680 : 84 : removexattr(struct dentry *d, const char __user *name)
681 : : {
682 : 84 : int error;
683 : 84 : char kname[XATTR_NAME_MAX + 1];
684 : :
685 : 84 : error = strncpy_from_user(kname, name, sizeof(kname));
686 [ + - ]: 84 : if (error == 0 || error == sizeof(kname))
687 : : error = -ERANGE;
688 [ - + ]: 84 : if (error < 0)
689 : 0 : return error;
690 : :
691 : 84 : return vfs_removexattr(d, kname);
692 : : }
693 : :
694 : 84 : static int path_removexattr(const char __user *pathname,
695 : : const char __user *name, unsigned int lookup_flags)
696 : : {
697 : 84 : struct path path;
698 : 84 : int error;
699 : 84 : retry:
700 : 84 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
701 [ - + ]: 84 : if (error)
702 : 0 : return error;
703 : 84 : error = mnt_want_write(path.mnt);
704 [ + - ]: 84 : if (!error) {
705 : 84 : error = removexattr(path.dentry, name);
706 : 84 : mnt_drop_write(path.mnt);
707 : : }
708 : 84 : path_put(&path);
709 [ - + - + ]: 168 : if (retry_estale(error, lookup_flags)) {
710 : 0 : lookup_flags |= LOOKUP_REVAL;
711 : 0 : goto retry;
712 : : }
713 : : return error;
714 : : }
715 : :
716 : 168 : SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
717 : : const char __user *, name)
718 : : {
719 : 84 : return path_removexattr(pathname, name, LOOKUP_FOLLOW);
720 : : }
721 : :
722 : 0 : SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
723 : : const char __user *, name)
724 : : {
725 : 0 : return path_removexattr(pathname, name, 0);
726 : : }
727 : :
728 : 0 : SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
729 : : {
730 : 0 : struct fd f = fdget(fd);
731 : 0 : int error = -EBADF;
732 : :
733 [ # # ]: 0 : if (!f.file)
734 : : return error;
735 : 0 : audit_file(f.file);
736 : 0 : error = mnt_want_write_file(f.file);
737 [ # # ]: 0 : if (!error) {
738 : 0 : error = removexattr(f.file->f_path.dentry, name);
739 : 0 : mnt_drop_write_file(f.file);
740 : : }
741 [ # # ]: 0 : fdput(f);
742 : 0 : return error;
743 : : }
744 : :
745 : : /*
746 : : * Combine the results of the list() operation from every xattr_handler in the
747 : : * list.
748 : : */
749 : : ssize_t
750 : 0 : generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
751 : : {
752 : 0 : const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
753 : 0 : unsigned int size = 0;
754 : :
755 [ # # ]: 0 : if (!buffer) {
756 [ # # # # ]: 0 : for_each_xattr_handler(handlers, handler) {
757 [ # # ]: 0 : if (!handler->name ||
758 [ # # # # ]: 0 : (handler->list && !handler->list(dentry)))
759 : 0 : continue;
760 : 0 : size += strlen(handler->name) + 1;
761 : : }
762 : : } else {
763 : 0 : char *buf = buffer;
764 : 0 : size_t len;
765 : :
766 [ # # # # ]: 0 : for_each_xattr_handler(handlers, handler) {
767 [ # # ]: 0 : if (!handler->name ||
768 [ # # # # ]: 0 : (handler->list && !handler->list(dentry)))
769 : 0 : continue;
770 : 0 : len = strlen(handler->name);
771 [ # # ]: 0 : if (len + 1 > buffer_size)
772 : : return -ERANGE;
773 : 0 : memcpy(buf, handler->name, len + 1);
774 : 0 : buf += len + 1;
775 : 0 : buffer_size -= len + 1;
776 : : }
777 : 0 : size = buf - buffer;
778 : : }
779 : 0 : return size;
780 : : }
781 : : EXPORT_SYMBOL(generic_listxattr);
782 : :
783 : : /**
784 : : * xattr_full_name - Compute full attribute name from suffix
785 : : *
786 : : * @handler: handler of the xattr_handler operation
787 : : * @name: name passed to the xattr_handler operation
788 : : *
789 : : * The get and set xattr handler operations are called with the remainder of
790 : : * the attribute name after skipping the handler's prefix: for example, "foo"
791 : : * is passed to the get operation of a handler with prefix "user." to get
792 : : * attribute "user.foo". The full name is still "there" in the name though.
793 : : *
794 : : * Note: the list xattr handler operation when called from the vfs is passed a
795 : : * NULL name; some file systems use this operation internally, with varying
796 : : * semantics.
797 : : */
798 : 5124 : const char *xattr_full_name(const struct xattr_handler *handler,
799 : : const char *name)
800 : : {
801 [ - + ]: 5124 : size_t prefix_len = strlen(xattr_prefix(handler));
802 : :
803 : 5124 : return name - prefix_len;
804 : : }
805 : : EXPORT_SYMBOL(xattr_full_name);
806 : :
807 : : /*
808 : : * Allocate new xattr and copy in the value; but leave the name to callers.
809 : : */
810 : 588 : struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
811 : : {
812 : 588 : struct simple_xattr *new_xattr;
813 : 588 : size_t len;
814 : :
815 : : /* wrap around? */
816 : 588 : len = sizeof(*new_xattr) + size;
817 [ + - ]: 588 : if (len < sizeof(*new_xattr))
818 : : return NULL;
819 : :
820 [ - + ]: 588 : new_xattr = kmalloc(len, GFP_KERNEL);
821 [ + - ]: 588 : if (!new_xattr)
822 : : return NULL;
823 : :
824 : 588 : new_xattr->size = size;
825 : 588 : memcpy(new_xattr->value, value, size);
826 : 588 : return new_xattr;
827 : : }
828 : :
829 : : /*
830 : : * xattr GET operation for in-memory/pseudo filesystems
831 : : */
832 : 4494 : int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
833 : : void *buffer, size_t size)
834 : : {
835 : 4494 : struct simple_xattr *xattr;
836 : 4494 : int ret = -ENODATA;
837 : :
838 : 4494 : spin_lock(&xattrs->lock);
839 [ - + ]: 4494 : list_for_each_entry(xattr, &xattrs->head, list) {
840 [ # # ]: 0 : if (strcmp(name, xattr->name))
841 : 0 : continue;
842 : :
843 : 0 : ret = xattr->size;
844 [ # # ]: 0 : if (buffer) {
845 [ # # ]: 0 : if (size < xattr->size)
846 : : ret = -ERANGE;
847 : : else
848 : 0 : memcpy(buffer, xattr->value, xattr->size);
849 : : }
850 : : break;
851 : : }
852 : 4494 : spin_unlock(&xattrs->lock);
853 : 4494 : return ret;
854 : : }
855 : :
856 : : /**
857 : : * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
858 : : * @xattrs: target simple_xattr list
859 : : * @name: name of the extended attribute
860 : : * @value: value of the xattr. If %NULL, will remove the attribute.
861 : : * @size: size of the new xattr
862 : : * @flags: %XATTR_{CREATE|REPLACE}
863 : : *
864 : : * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
865 : : * with -EEXIST. If %XATTR_REPLACE is set, the xattr should exist;
866 : : * otherwise, fails with -ENODATA.
867 : : *
868 : : * Returns 0 on success, -errno on failure.
869 : : */
870 : 588 : int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
871 : : const void *value, size_t size, int flags)
872 : : {
873 : 588 : struct simple_xattr *xattr;
874 : 588 : struct simple_xattr *new_xattr = NULL;
875 : 588 : int err = 0;
876 : :
877 : : /* value == NULL means remove */
878 [ + - ]: 588 : if (value) {
879 : 588 : new_xattr = simple_xattr_alloc(value, size);
880 [ + - ]: 588 : if (!new_xattr)
881 : : return -ENOMEM;
882 : :
883 : 588 : new_xattr->name = kstrdup(name, GFP_KERNEL);
884 [ - + ]: 588 : if (!new_xattr->name) {
885 : 0 : kfree(new_xattr);
886 : 0 : return -ENOMEM;
887 : : }
888 : : }
889 : :
890 : 588 : spin_lock(&xattrs->lock);
891 [ - + ]: 588 : list_for_each_entry(xattr, &xattrs->head, list) {
892 [ # # ]: 0 : if (!strcmp(name, xattr->name)) {
893 [ # # ]: 0 : if (flags & XATTR_CREATE) {
894 : : xattr = new_xattr;
895 : : err = -EEXIST;
896 [ # # ]: 0 : } else if (new_xattr) {
897 : 0 : list_replace(&xattr->list, &new_xattr->list);
898 : : } else {
899 : 0 : list_del(&xattr->list);
900 : : }
901 : 0 : goto out;
902 : : }
903 : : }
904 [ + - ]: 588 : if (flags & XATTR_REPLACE) {
905 : : xattr = new_xattr;
906 : : err = -ENODATA;
907 : : } else {
908 : 588 : list_add(&new_xattr->list, &xattrs->head);
909 : 588 : xattr = NULL;
910 : : }
911 : 588 : out:
912 : 588 : spin_unlock(&xattrs->lock);
913 [ - + ]: 588 : if (xattr) {
914 : 0 : kfree(xattr->name);
915 : 0 : kfree(xattr);
916 : : }
917 : : return err;
918 : :
919 : : }
920 : :
921 : 0 : static bool xattr_is_trusted(const char *name)
922 : : {
923 : 0 : return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
924 : : }
925 : :
926 : 0 : static int xattr_list_one(char **buffer, ssize_t *remaining_size,
927 : : const char *name)
928 : : {
929 : 0 : size_t len = strlen(name) + 1;
930 [ # # ]: 0 : if (*buffer) {
931 [ # # ]: 0 : if (*remaining_size < len)
932 : : return -ERANGE;
933 : 0 : memcpy(*buffer, name, len);
934 : 0 : *buffer += len;
935 : : }
936 : 0 : *remaining_size -= len;
937 : 0 : return 0;
938 : : }
939 : :
940 : : /*
941 : : * xattr LIST operation for in-memory/pseudo filesystems
942 : : */
943 : 0 : ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
944 : : char *buffer, size_t size)
945 : : {
946 : 0 : bool trusted = capable(CAP_SYS_ADMIN);
947 : 0 : struct simple_xattr *xattr;
948 : 0 : ssize_t remaining_size = size;
949 : 0 : int err = 0;
950 : :
951 : : #ifdef CONFIG_FS_POSIX_ACL
952 [ # # ]: 0 : if (IS_POSIXACL(inode)) {
953 [ # # ]: 0 : if (inode->i_acl) {
954 : 0 : err = xattr_list_one(&buffer, &remaining_size,
955 : : XATTR_NAME_POSIX_ACL_ACCESS);
956 [ # # ]: 0 : if (err)
957 : 0 : return err;
958 : : }
959 [ # # ]: 0 : if (inode->i_default_acl) {
960 : 0 : err = xattr_list_one(&buffer, &remaining_size,
961 : : XATTR_NAME_POSIX_ACL_DEFAULT);
962 [ # # ]: 0 : if (err)
963 : 0 : return err;
964 : : }
965 : : }
966 : : #endif
967 : :
968 : 0 : spin_lock(&xattrs->lock);
969 [ # # ]: 0 : list_for_each_entry(xattr, &xattrs->head, list) {
970 : : /* skip "trusted." attributes for unprivileged callers */
971 [ # # # # ]: 0 : if (!trusted && xattr_is_trusted(xattr->name))
972 : 0 : continue;
973 : :
974 : 0 : err = xattr_list_one(&buffer, &remaining_size, xattr->name);
975 [ # # ]: 0 : if (err)
976 : : break;
977 : : }
978 : 0 : spin_unlock(&xattrs->lock);
979 : :
980 [ # # ]: 0 : return err ? err : size - remaining_size;
981 : : }
982 : :
983 : : /*
984 : : * Adds an extended attribute to the list
985 : : */
986 : 0 : void simple_xattr_list_add(struct simple_xattrs *xattrs,
987 : : struct simple_xattr *new_xattr)
988 : : {
989 : 0 : spin_lock(&xattrs->lock);
990 : 0 : list_add(&new_xattr->list, &xattrs->head);
991 : 0 : spin_unlock(&xattrs->lock);
992 : 0 : }
|
