xref: /linux/fs/file_attr.c (revision 7ea30958b3054f5e488fa0b33c352723f7ab3a2a)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/fs.h>
3 #include <linux/security.h>
4 #include <linux/fscrypt.h>
5 #include <linux/fileattr.h>
6 #include <linux/export.h>
7 #include <linux/syscalls.h>
8 #include <linux/namei.h>
9 
10 #include "internal.h"
11 
12 /**
13  * fileattr_fill_xflags - initialize fileattr with xflags
14  * @fa:		fileattr pointer
15  * @xflags:	FS_XFLAG_* flags
16  *
17  * Set ->fsx_xflags, ->fsx_valid and ->flags (translated xflags).  All
18  * other fields are zeroed.
19  */
fileattr_fill_xflags(struct file_kattr * fa,u32 xflags)20 void fileattr_fill_xflags(struct file_kattr *fa, u32 xflags)
21 {
22 	memset(fa, 0, sizeof(*fa));
23 	fa->fsx_valid = true;
24 	fa->fsx_xflags = xflags;
25 	if (fa->fsx_xflags & FS_XFLAG_IMMUTABLE)
26 		fa->flags |= FS_IMMUTABLE_FL;
27 	if (fa->fsx_xflags & FS_XFLAG_APPEND)
28 		fa->flags |= FS_APPEND_FL;
29 	if (fa->fsx_xflags & FS_XFLAG_SYNC)
30 		fa->flags |= FS_SYNC_FL;
31 	if (fa->fsx_xflags & FS_XFLAG_NOATIME)
32 		fa->flags |= FS_NOATIME_FL;
33 	if (fa->fsx_xflags & FS_XFLAG_NODUMP)
34 		fa->flags |= FS_NODUMP_FL;
35 	if (fa->fsx_xflags & FS_XFLAG_DAX)
36 		fa->flags |= FS_DAX_FL;
37 	if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)
38 		fa->flags |= FS_PROJINHERIT_FL;
39 }
40 EXPORT_SYMBOL(fileattr_fill_xflags);
41 
42 /**
43  * fileattr_fill_flags - initialize fileattr with flags
44  * @fa:		fileattr pointer
45  * @flags:	FS_*_FL flags
46  *
47  * Set ->flags, ->flags_valid and ->fsx_xflags (translated flags).
48  * All other fields are zeroed.
49  */
fileattr_fill_flags(struct file_kattr * fa,u32 flags)50 void fileattr_fill_flags(struct file_kattr *fa, u32 flags)
51 {
52 	memset(fa, 0, sizeof(*fa));
53 	fa->flags_valid = true;
54 	fa->flags = flags;
55 	if (fa->flags & FS_SYNC_FL)
56 		fa->fsx_xflags |= FS_XFLAG_SYNC;
57 	if (fa->flags & FS_IMMUTABLE_FL)
58 		fa->fsx_xflags |= FS_XFLAG_IMMUTABLE;
59 	if (fa->flags & FS_APPEND_FL)
60 		fa->fsx_xflags |= FS_XFLAG_APPEND;
61 	if (fa->flags & FS_NODUMP_FL)
62 		fa->fsx_xflags |= FS_XFLAG_NODUMP;
63 	if (fa->flags & FS_NOATIME_FL)
64 		fa->fsx_xflags |= FS_XFLAG_NOATIME;
65 	if (fa->flags & FS_DAX_FL)
66 		fa->fsx_xflags |= FS_XFLAG_DAX;
67 	if (fa->flags & FS_PROJINHERIT_FL)
68 		fa->fsx_xflags |= FS_XFLAG_PROJINHERIT;
69 }
70 EXPORT_SYMBOL(fileattr_fill_flags);
71 
72 /**
73  * vfs_fileattr_get - retrieve miscellaneous file attributes
74  * @dentry:	the object to retrieve from
75  * @fa:		fileattr pointer
76  *
77  * Call i_op->fileattr_get() callback, if exists.
78  *
79  * Return: 0 on success, or a negative error on failure.
80  */
vfs_fileattr_get(struct dentry * dentry,struct file_kattr * fa)81 int vfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
82 {
83 	struct inode *inode = d_inode(dentry);
84 	int error;
85 
86 	if (!inode->i_op->fileattr_get)
87 		return -ENOIOCTLCMD;
88 
89 	error = security_inode_file_getattr(dentry, fa);
90 	if (error)
91 		return error;
92 
93 	return inode->i_op->fileattr_get(dentry, fa);
94 }
95 EXPORT_SYMBOL(vfs_fileattr_get);
96 
fileattr_to_file_attr(const struct file_kattr * fa,struct file_attr * fattr)97 static void fileattr_to_file_attr(const struct file_kattr *fa,
98 				  struct file_attr *fattr)
99 {
100 	__u32 mask = FS_XFLAGS_MASK;
101 
102 	memset(fattr, 0, sizeof(struct file_attr));
103 	fattr->fa_xflags = fa->fsx_xflags & mask;
104 	fattr->fa_extsize = fa->fsx_extsize;
105 	fattr->fa_nextents = fa->fsx_nextents;
106 	fattr->fa_projid = fa->fsx_projid;
107 	fattr->fa_cowextsize = fa->fsx_cowextsize;
108 }
109 
110 /**
111  * copy_fsxattr_to_user - copy fsxattr to userspace.
112  * @fa:		fileattr pointer
113  * @ufa:	fsxattr user pointer
114  *
115  * Return: 0 on success, or -EFAULT on failure.
116  */
copy_fsxattr_to_user(const struct file_kattr * fa,struct fsxattr __user * ufa)117 int copy_fsxattr_to_user(const struct file_kattr *fa, struct fsxattr __user *ufa)
118 {
119 	struct fsxattr xfa;
120 	__u32 mask = FS_XFLAGS_MASK;
121 
122 	memset(&xfa, 0, sizeof(xfa));
123 	xfa.fsx_xflags = fa->fsx_xflags & mask;
124 	xfa.fsx_extsize = fa->fsx_extsize;
125 	xfa.fsx_nextents = fa->fsx_nextents;
126 	xfa.fsx_projid = fa->fsx_projid;
127 	xfa.fsx_cowextsize = fa->fsx_cowextsize;
128 
129 	if (copy_to_user(ufa, &xfa, sizeof(xfa)))
130 		return -EFAULT;
131 
132 	return 0;
133 }
134 EXPORT_SYMBOL(copy_fsxattr_to_user);
135 
file_attr_to_fileattr(const struct file_attr * fattr,struct file_kattr * fa)136 static int file_attr_to_fileattr(const struct file_attr *fattr,
137 				 struct file_kattr *fa)
138 {
139 	__u64 mask = FS_XFLAGS_MASK;
140 
141 	if (fattr->fa_xflags & ~mask)
142 		return -EINVAL;
143 
144 	fileattr_fill_xflags(fa, fattr->fa_xflags);
145 	fa->fsx_xflags &= ~FS_XFLAG_RDONLY_MASK;
146 	fa->fsx_extsize = fattr->fa_extsize;
147 	fa->fsx_projid = fattr->fa_projid;
148 	fa->fsx_cowextsize = fattr->fa_cowextsize;
149 
150 	return 0;
151 }
152 
copy_fsxattr_from_user(struct file_kattr * fa,struct fsxattr __user * ufa)153 static int copy_fsxattr_from_user(struct file_kattr *fa,
154 				  struct fsxattr __user *ufa)
155 {
156 	struct fsxattr xfa;
157 	__u32 mask = FS_XFLAGS_MASK;
158 
159 	if (copy_from_user(&xfa, ufa, sizeof(xfa)))
160 		return -EFAULT;
161 
162 	if (xfa.fsx_xflags & ~mask)
163 		return -EOPNOTSUPP;
164 
165 	fileattr_fill_xflags(fa, xfa.fsx_xflags);
166 	fa->fsx_xflags &= ~FS_XFLAG_RDONLY_MASK;
167 	fa->fsx_extsize = xfa.fsx_extsize;
168 	fa->fsx_nextents = xfa.fsx_nextents;
169 	fa->fsx_projid = xfa.fsx_projid;
170 	fa->fsx_cowextsize = xfa.fsx_cowextsize;
171 
172 	return 0;
173 }
174 
175 /*
176  * Generic function to check FS_IOC_FSSETXATTR/FS_IOC_SETFLAGS values and reject
177  * any invalid configurations.
178  *
179  * Note: must be called with inode lock held.
180  */
fileattr_set_prepare(struct inode * inode,const struct file_kattr * old_ma,struct file_kattr * fa)181 static int fileattr_set_prepare(struct inode *inode,
182 			      const struct file_kattr *old_ma,
183 			      struct file_kattr *fa)
184 {
185 	int err;
186 
187 	/*
188 	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
189 	 * the relevant capability.
190 	 */
191 	if ((fa->flags ^ old_ma->flags) & (FS_APPEND_FL | FS_IMMUTABLE_FL) &&
192 	    !capable(CAP_LINUX_IMMUTABLE))
193 		return -EPERM;
194 
195 	err = fscrypt_prepare_setflags(inode, old_ma->flags, fa->flags);
196 	if (err)
197 		return err;
198 
199 	/*
200 	 * Project Quota ID state is only allowed to change from within the init
201 	 * namespace. Enforce that restriction only if we are trying to change
202 	 * the quota ID state. Everything else is allowed in user namespaces.
203 	 */
204 	if (current_user_ns() != &init_user_ns) {
205 		if (old_ma->fsx_projid != fa->fsx_projid)
206 			return -EINVAL;
207 		if ((old_ma->fsx_xflags ^ fa->fsx_xflags) &
208 				FS_XFLAG_PROJINHERIT)
209 			return -EINVAL;
210 	} else {
211 		/*
212 		 * Caller is allowed to change the project ID. If it is being
213 		 * changed, make sure that the new value is valid.
214 		 */
215 		if (old_ma->fsx_projid != fa->fsx_projid &&
216 		    !projid_valid(make_kprojid(&init_user_ns, fa->fsx_projid)))
217 			return -EINVAL;
218 	}
219 
220 	/* Check extent size hints. */
221 	if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(inode->i_mode))
222 		return -EINVAL;
223 
224 	if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) &&
225 			!S_ISDIR(inode->i_mode))
226 		return -EINVAL;
227 
228 	if ((fa->fsx_xflags & FS_XFLAG_COWEXTSIZE) &&
229 	    !S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
230 		return -EINVAL;
231 
232 	/*
233 	 * It is only valid to set the DAX flag on regular files and
234 	 * directories on filesystems.
235 	 */
236 	if ((fa->fsx_xflags & FS_XFLAG_DAX) &&
237 	    !(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
238 		return -EINVAL;
239 
240 	/* Extent size hints of zero turn off the flags. */
241 	if (fa->fsx_extsize == 0)
242 		fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT);
243 	if (fa->fsx_cowextsize == 0)
244 		fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
245 
246 	return 0;
247 }
248 
249 /**
250  * vfs_fileattr_set - change miscellaneous file attributes
251  * @idmap:	idmap of the mount
252  * @dentry:	the object to change
253  * @fa:		fileattr pointer
254  *
255  * After verifying permissions, call i_op->fileattr_set() callback, if
256  * exists.
257  *
258  * Verifying attributes involves retrieving current attributes with
259  * i_op->fileattr_get(), this also allows initializing attributes that have
260  * not been set by the caller to current values.  Inode lock is held
261  * thoughout to prevent racing with another instance.
262  *
263  * Return: 0 on success, or a negative error on failure.
264  */
vfs_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct file_kattr * fa)265 int vfs_fileattr_set(struct mnt_idmap *idmap, struct dentry *dentry,
266 		     struct file_kattr *fa)
267 {
268 	struct inode *inode = d_inode(dentry);
269 	struct file_kattr old_ma = {};
270 	int err;
271 
272 	if (!inode->i_op->fileattr_set)
273 		return -ENOIOCTLCMD;
274 
275 	if (!inode_owner_or_capable(idmap, inode))
276 		return -EPERM;
277 
278 	inode_lock(inode);
279 	err = vfs_fileattr_get(dentry, &old_ma);
280 	if (!err) {
281 		/* initialize missing bits from old_ma */
282 		if (fa->flags_valid) {
283 			fa->fsx_xflags |= old_ma.fsx_xflags & ~FS_XFLAG_COMMON;
284 			fa->fsx_extsize = old_ma.fsx_extsize;
285 			fa->fsx_nextents = old_ma.fsx_nextents;
286 			fa->fsx_projid = old_ma.fsx_projid;
287 			fa->fsx_cowextsize = old_ma.fsx_cowextsize;
288 		} else {
289 			fa->flags |= old_ma.flags & ~FS_COMMON_FL;
290 		}
291 
292 		err = fileattr_set_prepare(inode, &old_ma, fa);
293 		if (err)
294 			goto out;
295 		err = security_inode_file_setattr(dentry, fa);
296 		if (err)
297 			goto out;
298 		err = inode->i_op->fileattr_set(idmap, dentry, fa);
299 		if (err)
300 			goto out;
301 	}
302 
303 out:
304 	inode_unlock(inode);
305 	return err;
306 }
307 EXPORT_SYMBOL(vfs_fileattr_set);
308 
ioctl_getflags(struct file * file,unsigned int __user * argp)309 int ioctl_getflags(struct file *file, unsigned int __user *argp)
310 {
311 	struct file_kattr fa = { .flags_valid = true }; /* hint only */
312 	int err;
313 
314 	err = vfs_fileattr_get(file->f_path.dentry, &fa);
315 	if (!err)
316 		err = put_user(fa.flags, argp);
317 	return err;
318 }
319 EXPORT_SYMBOL(ioctl_getflags);
320 
ioctl_setflags(struct file * file,unsigned int __user * argp)321 int ioctl_setflags(struct file *file, unsigned int __user *argp)
322 {
323 	struct mnt_idmap *idmap = file_mnt_idmap(file);
324 	struct dentry *dentry = file->f_path.dentry;
325 	struct file_kattr fa;
326 	unsigned int flags;
327 	int err;
328 
329 	err = get_user(flags, argp);
330 	if (!err) {
331 		err = mnt_want_write_file(file);
332 		if (!err) {
333 			fileattr_fill_flags(&fa, flags);
334 			err = vfs_fileattr_set(idmap, dentry, &fa);
335 			mnt_drop_write_file(file);
336 		}
337 	}
338 	return err;
339 }
340 EXPORT_SYMBOL(ioctl_setflags);
341 
ioctl_fsgetxattr(struct file * file,void __user * argp)342 int ioctl_fsgetxattr(struct file *file, void __user *argp)
343 {
344 	struct file_kattr fa = { .fsx_valid = true }; /* hint only */
345 	int err;
346 
347 	err = vfs_fileattr_get(file->f_path.dentry, &fa);
348 	if (!err)
349 		err = copy_fsxattr_to_user(&fa, argp);
350 
351 	return err;
352 }
353 EXPORT_SYMBOL(ioctl_fsgetxattr);
354 
ioctl_fssetxattr(struct file * file,void __user * argp)355 int ioctl_fssetxattr(struct file *file, void __user *argp)
356 {
357 	struct mnt_idmap *idmap = file_mnt_idmap(file);
358 	struct dentry *dentry = file->f_path.dentry;
359 	struct file_kattr fa;
360 	int err;
361 
362 	err = copy_fsxattr_from_user(&fa, argp);
363 	if (!err) {
364 		err = mnt_want_write_file(file);
365 		if (!err) {
366 			err = vfs_fileattr_set(idmap, dentry, &fa);
367 			mnt_drop_write_file(file);
368 		}
369 	}
370 	return err;
371 }
372 EXPORT_SYMBOL(ioctl_fssetxattr);
373 
SYSCALL_DEFINE5(file_getattr,int,dfd,const char __user *,filename,struct file_attr __user *,ufattr,size_t,usize,unsigned int,at_flags)374 SYSCALL_DEFINE5(file_getattr, int, dfd, const char __user *, filename,
375 		struct file_attr __user *, ufattr, size_t, usize,
376 		unsigned int, at_flags)
377 {
378 	struct path filepath __free(path_put) = {};
379 	struct filename *name __free(putname) = NULL;
380 	unsigned int lookup_flags = 0;
381 	struct file_attr fattr;
382 	struct file_kattr fa;
383 	int error;
384 
385 	BUILD_BUG_ON(sizeof(struct file_attr) < FILE_ATTR_SIZE_VER0);
386 	BUILD_BUG_ON(sizeof(struct file_attr) != FILE_ATTR_SIZE_LATEST);
387 
388 	if ((at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
389 		return -EINVAL;
390 
391 	if (!(at_flags & AT_SYMLINK_NOFOLLOW))
392 		lookup_flags |= LOOKUP_FOLLOW;
393 
394 	if (usize > PAGE_SIZE)
395 		return -E2BIG;
396 
397 	if (usize < FILE_ATTR_SIZE_VER0)
398 		return -EINVAL;
399 
400 	name = getname_maybe_null(filename, at_flags);
401 	if (IS_ERR(name))
402 		return PTR_ERR(name);
403 
404 	if (!name && dfd >= 0) {
405 		CLASS(fd, f)(dfd);
406 		if (fd_empty(f))
407 			return -EBADF;
408 
409 		filepath = fd_file(f)->f_path;
410 		path_get(&filepath);
411 	} else {
412 		error = filename_lookup(dfd, name, lookup_flags, &filepath,
413 					NULL);
414 		if (error)
415 			return error;
416 	}
417 
418 	error = vfs_fileattr_get(filepath.dentry, &fa);
419 	if (error == -ENOIOCTLCMD || error == -ENOTTY)
420 		error = -EOPNOTSUPP;
421 	if (error)
422 		return error;
423 
424 	fileattr_to_file_attr(&fa, &fattr);
425 	error = copy_struct_to_user(ufattr, usize, &fattr,
426 				    sizeof(struct file_attr), NULL);
427 
428 	return error;
429 }
430 
SYSCALL_DEFINE5(file_setattr,int,dfd,const char __user *,filename,struct file_attr __user *,ufattr,size_t,usize,unsigned int,at_flags)431 SYSCALL_DEFINE5(file_setattr, int, dfd, const char __user *, filename,
432 		struct file_attr __user *, ufattr, size_t, usize,
433 		unsigned int, at_flags)
434 {
435 	struct path filepath __free(path_put) = {};
436 	struct filename *name __free(putname) = NULL;
437 	unsigned int lookup_flags = 0;
438 	struct file_attr fattr;
439 	struct file_kattr fa;
440 	int error;
441 
442 	BUILD_BUG_ON(sizeof(struct file_attr) < FILE_ATTR_SIZE_VER0);
443 	BUILD_BUG_ON(sizeof(struct file_attr) != FILE_ATTR_SIZE_LATEST);
444 
445 	if ((at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
446 		return -EINVAL;
447 
448 	if (!(at_flags & AT_SYMLINK_NOFOLLOW))
449 		lookup_flags |= LOOKUP_FOLLOW;
450 
451 	if (usize > PAGE_SIZE)
452 		return -E2BIG;
453 
454 	if (usize < FILE_ATTR_SIZE_VER0)
455 		return -EINVAL;
456 
457 	error = copy_struct_from_user(&fattr, sizeof(struct file_attr), ufattr,
458 				      usize);
459 	if (error)
460 		return error;
461 
462 	error = file_attr_to_fileattr(&fattr, &fa);
463 	if (error)
464 		return error;
465 
466 	name = getname_maybe_null(filename, at_flags);
467 	if (IS_ERR(name))
468 		return PTR_ERR(name);
469 
470 	if (!name && dfd >= 0) {
471 		CLASS(fd, f)(dfd);
472 		if (fd_empty(f))
473 			return -EBADF;
474 
475 		filepath = fd_file(f)->f_path;
476 		path_get(&filepath);
477 	} else {
478 		error = filename_lookup(dfd, name, lookup_flags, &filepath,
479 					NULL);
480 		if (error)
481 			return error;
482 	}
483 
484 	error = mnt_want_write(filepath.mnt);
485 	if (!error) {
486 		error = vfs_fileattr_set(mnt_idmap(filepath.mnt),
487 					 filepath.dentry, &fa);
488 		if (error == -ENOIOCTLCMD || error == -ENOTTY)
489 			error = -EOPNOTSUPP;
490 		mnt_drop_write(filepath.mnt);
491 	}
492 
493 	return error;
494 }
495