blob: 98f6601fbac65e564f072cfaf42835725e19aa83 [file] [log] [blame]
Thomas Gleixner457c8992019-05-19 13:08:55 +01001// SPDX-License-Identifier: GPL-2.0-only
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/fs/open.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 */
7
8#include <linux/string.h>
9#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040011#include <linux/fdtable.h>
Robert Love0eeca282005-07-12 17:06:03 -040012#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/tty.h>
15#include <linux/namei.h>
16#include <linux/backing-dev.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080017#include <linux/capability.h>
Andrew G. Morgan086f7312008-07-04 09:59:58 -070018#include <linux/securebits.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/security.h>
20#include <linux/mount.h>
Ulrich Drepper5590ff02006-01-18 17:43:53 -080021#include <linux/fcntl.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080023#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/fs.h>
Yoav Zachef3daed2005-06-23 00:09:58 -070025#include <linux/personality.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/pagemap.h>
27#include <linux/syscalls.h>
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070028#include <linux/rcupdate.h>
Amy Griffis73241cc2005-11-03 16:00:25 +000029#include <linux/audit.h>
Amit Arora97ac7352007-07-17 21:42:44 -040030#include <linux/falloc.h>
Al Viro5ad4e532009-03-29 19:50:06 -040031#include <linux/fs_struct.h>
Al Virob65a9cf2009-12-16 06:27:40 -050032#include <linux/ima.h>
Eric Paris2dfc1ca2009-12-17 20:30:52 -050033#include <linux/dnotify.h>
Al Viro3f6d0782013-02-24 13:49:08 -050034#include <linux/compat.h>
Christian Braunera793d792021-12-03 12:16:59 +010035#include <linux/mnt_idmapping.h>
Jeff Layton5970e152022-11-20 09:15:34 -050036#include <linux/filelock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Eric Parise81e3f42009-12-04 15:47:36 -050038#include "internal.h"
39
Christian Braunerabf08572023-01-13 12:49:10 +010040int do_truncate(struct mnt_idmap *idmap, struct dentry *dentry,
Christian Brauner643fe552021-01-21 14:19:34 +010041 loff_t length, unsigned int time_attrs, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
Amerigo Wang939a9422009-08-20 19:29:03 -070043 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 struct iattr newattrs;
45
46 /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
47 if (length < 0)
48 return -EINVAL;
49
50 newattrs.ia_size = length;
NeilBrown4a301312006-01-08 01:02:39 -080051 newattrs.ia_valid = ATTR_SIZE | time_attrs;
Miklos Szeredicc4e69d2005-11-07 00:59:49 -080052 if (filp) {
53 newattrs.ia_file = filp;
54 newattrs.ia_valid |= ATTR_FILE;
55 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Jan Kara45f147a2015-05-21 16:05:55 +020057 /* Remove suid, sgid, and file capabilities on truncate too */
Christian Brauner9452e932023-01-13 12:49:27 +010058 ret = dentry_needs_remove_privs(idmap, dentry);
Jan Kara45f147a2015-05-21 16:05:55 +020059 if (ret < 0)
60 return ret;
Amerigo Wang939a9422009-08-20 19:29:03 -070061 if (ret)
62 newattrs.ia_valid |= ret | ATTR_FORCE;
Linus Torvalds7b82dc02007-05-08 20:10:00 -070063
Al Viro59551022016-01-22 15:40:57 -050064 inode_lock(dentry->d_inode);
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -040065 /* Note any delegations or leases have already been broken: */
Christian Braunerabf08572023-01-13 12:49:10 +010066 ret = notify_change(idmap, dentry, &newattrs, NULL);
Al Viro59551022016-01-22 15:40:57 -050067 inode_unlock(dentry->d_inode);
Amerigo Wang939a9422009-08-20 19:29:03 -070068 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
70
Al Viro7df818b2016-03-25 14:24:09 -040071long vfs_truncate(const struct path *path, loff_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Christian Braunerabf08572023-01-13 12:49:10 +010073 struct mnt_idmap *idmap;
Al Viro2d8f3032008-07-22 09:59:21 -040074 struct inode *inode;
David Howellsa02de962012-12-20 21:52:36 +000075 long error;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
David Howellsa02de962012-12-20 21:52:36 +000077 inode = path->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79 /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 if (S_ISDIR(inode->i_mode))
David Howellsa02de962012-12-20 21:52:36 +000081 return -EISDIR;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 if (!S_ISREG(inode->i_mode))
David Howellsa02de962012-12-20 21:52:36 +000083 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
David Howellsa02de962012-12-20 21:52:36 +000085 error = mnt_want_write(path->mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (error)
David Howellsa02de962012-12-20 21:52:36 +000087 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Christian Braunerabf08572023-01-13 12:49:10 +010089 idmap = mnt_idmap(path->mnt);
Christian Brauner4609e1f2023-01-13 12:49:22 +010090 error = inode_permission(idmap, inode, MAY_WRITE);
Dave Hansen9ac9b842008-02-15 14:37:52 -080091 if (error)
92 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 error = -EPERM;
Miklos Szeredic82e42d2008-06-24 16:50:12 +020095 if (IS_APPEND(inode))
Dave Hansen9ac9b842008-02-15 14:37:52 -080096 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Miklos Szeredi8cf9ee52018-07-18 15:44:43 +020098 error = get_write_access(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (error)
Dave Hansen9ac9b842008-02-15 14:37:52 -0800100 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
david m. richter97003822007-07-31 00:39:12 -0700102 /*
103 * Make sure that there are no leases. get_write_access() protects
104 * against the truncate racing with a lease-granting setlease().
105 */
Al Viro8737c932009-12-24 06:47:55 -0500106 error = break_lease(inode, O_WRONLY);
david m. richter97003822007-07-31 00:39:12 -0700107 if (error)
108 goto put_write_and_out;
109
Jeff Laytonf7e33bd2021-08-19 14:56:38 -0400110 error = security_path_truncate(path);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500111 if (!error)
Christian Braunerabf08572023-01-13 12:49:10 +0100112 error = do_truncate(idmap, path->dentry, length, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
david m. richter97003822007-07-31 00:39:12 -0700114put_write_and_out:
Miklos Szeredi8cf9ee52018-07-18 15:44:43 +0200115 put_write_access(inode);
Dave Hansen9ac9b842008-02-15 14:37:52 -0800116mnt_drop_write_and_out:
David Howellsa02de962012-12-20 21:52:36 +0000117 mnt_drop_write(path->mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118out:
119 return error;
120}
David Howellsa02de962012-12-20 21:52:36 +0000121EXPORT_SYMBOL_GPL(vfs_truncate);
122
Dominik Brodowskidf260e22018-03-19 17:32:11 +0100123long do_sys_truncate(const char __user *pathname, loff_t length)
David Howellsa02de962012-12-20 21:52:36 +0000124{
Jeff Layton48f75302012-12-11 12:10:11 -0500125 unsigned int lookup_flags = LOOKUP_FOLLOW;
David Howellsa02de962012-12-20 21:52:36 +0000126 struct path path;
127 int error;
128
129 if (length < 0) /* sorry, but loff_t says... */
130 return -EINVAL;
131
Jeff Layton48f75302012-12-11 12:10:11 -0500132retry:
133 error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
David Howellsa02de962012-12-20 21:52:36 +0000134 if (!error) {
135 error = vfs_truncate(&path, length);
136 path_put(&path);
137 }
Jeff Layton48f75302012-12-11 12:10:11 -0500138 if (retry_estale(error, lookup_flags)) {
139 lookup_flags |= LOOKUP_REVAL;
140 goto retry;
141 }
David Howellsa02de962012-12-20 21:52:36 +0000142 return error;
143}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Heiko Carstens4fd8da82009-09-23 17:49:55 +0200145SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Heiko Carstens4fd8da82009-09-23 17:49:55 +0200147 return do_sys_truncate(path, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Al Viro3f6d0782013-02-24 13:49:08 -0500150#ifdef CONFIG_COMPAT
151COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
152{
153 return do_sys_truncate(path, length);
154}
155#endif
156
Dominik Brodowski411d9472018-03-11 11:34:54 +0100157long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
Al Virobf2965d2012-08-26 20:13:36 -0400159 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 struct dentry *dentry;
Al Viro2903ff02012-08-28 12:52:22 -0400161 struct fd f;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 int error;
163
164 error = -EINVAL;
165 if (length < 0)
166 goto out;
167 error = -EBADF;
Al Viro2903ff02012-08-28 12:52:22 -0400168 f = fdget(fd);
169 if (!f.file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 goto out;
171
172 /* explicitly opened as large or we are on 64-bit box */
Al Viro2903ff02012-08-28 12:52:22 -0400173 if (f.file->f_flags & O_LARGEFILE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 small = 0;
175
Al Viro2903ff02012-08-28 12:52:22 -0400176 dentry = f.file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 inode = dentry->d_inode;
178 error = -EINVAL;
Al Viro2903ff02012-08-28 12:52:22 -0400179 if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 goto out_putf;
181
182 error = -EINVAL;
183 /* Cannot ftruncate over 2^31 bytes without large file support */
184 if (small && length > MAX_NON_LFS)
185 goto out_putf;
186
187 error = -EPERM;
Amir Goldstein78757af2017-04-08 14:49:06 +0300188 /* Check IS_APPEND on real upper inode */
189 if (IS_APPEND(file_inode(f.file)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 goto out_putf;
Jan Kara14da9202012-06-12 16:20:37 +0200191 sb_start_write(inode->i_sb);
Günther Noack33506072022-10-18 20:22:06 +0200192 error = security_file_truncate(f.file);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +0900193 if (!error)
Christian Braunerabf08572023-01-13 12:49:10 +0100194 error = do_truncate(file_mnt_idmap(f.file), dentry, length,
Christian Brauner643fe552021-01-21 14:19:34 +0100195 ATTR_MTIME | ATTR_CTIME, f.file);
Jan Kara14da9202012-06-12 16:20:37 +0200196 sb_end_write(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197out_putf:
Al Viro2903ff02012-08-28 12:52:22 -0400198 fdput(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199out:
200 return error;
201}
202
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100203SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Al Viro2cf09662013-01-21 15:25:54 -0500205 return do_sys_ftruncate(fd, length, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
Al Viro3f6d0782013-02-24 13:49:08 -0500208#ifdef CONFIG_COMPAT
209COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
210{
211 return do_sys_ftruncate(fd, length, 1);
212}
213#endif
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215/* LFS versions of truncate are only needed on 32 bit machines */
216#if BITS_PER_LONG == 32
Al Viro4a0fd5b2013-01-21 15:16:58 -0500217SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 return do_sys_truncate(path, length);
220}
221
Al Viro4a0fd5b2013-01-21 15:16:58 -0500222SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
Al Viro2cf09662013-01-21 15:25:54 -0500224 return do_sys_ftruncate(fd, length, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225}
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100226#endif /* BITS_PER_LONG == 32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Guo Ren59c10c52022-04-05 15:13:05 +0800228#if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_TRUNCATE64)
229COMPAT_SYSCALL_DEFINE3(truncate64, const char __user *, pathname,
230 compat_arg_u64_dual(length))
231{
232 return ksys_truncate(pathname, compat_arg_u64_glue(length));
233}
234#endif
235
236#if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_FTRUNCATE64)
237COMPAT_SYSCALL_DEFINE3(ftruncate64, unsigned int, fd,
238 compat_arg_u64_dual(length))
239{
240 return ksys_ftruncate(fd, compat_arg_u64_glue(length));
241}
242#endif
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400243
Anna Schumaker72c72bd2014-11-07 14:44:25 -0500244int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
Amit Arora97ac7352007-07-17 21:42:44 -0400245{
Al Viro496ad9a2013-01-23 17:07:38 -0500246 struct inode *inode = file_inode(file);
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400247 long ret;
Amit Arora97ac7352007-07-17 21:42:44 -0400248
249 if (offset < 0 || len <= 0)
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400250 return -EINVAL;
Amit Arora97ac7352007-07-17 21:42:44 -0400251
252 /* Return error if mode is not supported */
Namjae Jeondd46c782015-03-25 15:07:05 +1100253 if (mode & ~FALLOC_FL_SUPPORTED_MASK)
Lukas Czerner409332b2014-03-13 19:07:42 +1100254 return -EOPNOTSUPP;
255
256 /* Punch hole and zero range are mutually exclusive */
257 if ((mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE)) ==
258 (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE))
Josef Bacik79124f182010-11-17 20:46:15 -0500259 return -EOPNOTSUPP;
260
261 /* Punch hole must have keep size set */
262 if ((mode & FALLOC_FL_PUNCH_HOLE) &&
263 !(mode & FALLOC_FL_KEEP_SIZE))
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400264 return -EOPNOTSUPP;
Amit Arora97ac7352007-07-17 21:42:44 -0400265
Namjae Jeon00f5e612014-02-24 10:58:15 +1100266 /* Collapse range should only be used exclusively. */
267 if ((mode & FALLOC_FL_COLLAPSE_RANGE) &&
268 (mode & ~FALLOC_FL_COLLAPSE_RANGE))
269 return -EINVAL;
270
Namjae Jeondd46c782015-03-25 15:07:05 +1100271 /* Insert range should only be used exclusively. */
272 if ((mode & FALLOC_FL_INSERT_RANGE) &&
273 (mode & ~FALLOC_FL_INSERT_RANGE))
274 return -EINVAL;
275
Darrick J. Wong71be6b42016-10-03 09:11:14 -0700276 /* Unshare range should only be used with allocate mode. */
277 if ((mode & FALLOC_FL_UNSHARE_RANGE) &&
278 (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))
279 return -EINVAL;
280
Amit Arora97ac7352007-07-17 21:42:44 -0400281 if (!(file->f_mode & FMODE_WRITE))
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400282 return -EBADF;
Marco Stornelli1ca551c2011-03-05 11:10:19 +0100283
Namjae Jeon00f5e612014-02-24 10:58:15 +1100284 /*
Lukas Czerner8fc61d92014-04-12 09:51:34 -0400285 * We can only allow pure fallocate on append only files
Namjae Jeon00f5e612014-02-24 10:58:15 +1100286 */
Lukas Czerner8fc61d92014-04-12 09:51:34 -0400287 if ((mode & ~FALLOC_FL_KEEP_SIZE) && IS_APPEND(inode))
Marco Stornelli1ca551c2011-03-05 11:10:19 +0100288 return -EPERM;
289
290 if (IS_IMMUTABLE(inode))
291 return -EPERM;
292
Amit Arora97ac7352007-07-17 21:42:44 -0400293 /*
Eric Biggers6d2b6172014-06-24 23:45:08 -0500294 * We cannot allow any fallocate operation on an active swapfile
Lukas Czerner0790b312014-04-12 10:05:37 -0400295 */
296 if (IS_SWAPFILE(inode))
Eric Biggers6d2b6172014-06-24 23:45:08 -0500297 return -ETXTBSY;
Lukas Czerner0790b312014-04-12 10:05:37 -0400298
299 /*
Amit Arora97ac7352007-07-17 21:42:44 -0400300 * Revalidate the write permissions, in case security policy has
301 * changed since the files were opened.
302 */
303 ret = security_file_permission(file, MAY_WRITE);
304 if (ret)
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400305 return ret;
Amit Arora97ac7352007-07-17 21:42:44 -0400306
Amit Arora97ac7352007-07-17 21:42:44 -0400307 if (S_ISFIFO(inode->i_mode))
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400308 return -ESPIPE;
Amit Arora97ac7352007-07-17 21:42:44 -0400309
Amir Goldstein9e79b132017-01-31 10:34:55 +0200310 if (S_ISDIR(inode->i_mode))
311 return -EISDIR;
312
313 if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400314 return -ENODEV;
Amit Arora97ac7352007-07-17 21:42:44 -0400315
Amit Arora97ac7352007-07-17 21:42:44 -0400316 /* Check for wrap through zero too */
317 if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400318 return -EFBIG;
Amit Arora97ac7352007-07-17 21:42:44 -0400319
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100320 if (!file->f_op->fallocate)
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400321 return -EOPNOTSUPP;
Amit Arora97ac7352007-07-17 21:42:44 -0400322
Amir Goldsteinbfe219d2017-01-31 10:34:57 +0200323 file_start_write(file);
Jan Kara14da9202012-06-12 16:20:37 +0200324 ret = file->f_op->fallocate(file, mode, offset, len);
Heinrich Schuchardt820c12d2014-12-12 16:58:34 -0800325
326 /*
327 * Create inotify and fanotify events.
328 *
329 * To keep the logic simple always create events if fallocate succeeds.
330 * This implies that events are even created if the file size remains
331 * unchanged, e.g. when using flag FALLOC_FL_KEEP_SIZE.
332 */
333 if (ret == 0)
334 fsnotify_modify(file);
335
Amir Goldsteinbfe219d2017-01-31 10:34:57 +0200336 file_end_write(file);
Jan Kara14da9202012-06-12 16:20:37 +0200337 return ret;
Amit Arora97ac7352007-07-17 21:42:44 -0400338}
Anna Schumaker72c72bd2014-11-07 14:44:25 -0500339EXPORT_SYMBOL_GPL(vfs_fallocate);
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400340
Dominik Brodowskiedf292c2018-03-19 17:46:32 +0100341int ksys_fallocate(int fd, int mode, loff_t offset, loff_t len)
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400342{
Al Viro2903ff02012-08-28 12:52:22 -0400343 struct fd f = fdget(fd);
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400344 int error = -EBADF;
345
Al Viro2903ff02012-08-28 12:52:22 -0400346 if (f.file) {
Anna Schumaker72c72bd2014-11-07 14:44:25 -0500347 error = vfs_fallocate(f.file, mode, offset, len);
Al Viro2903ff02012-08-28 12:52:22 -0400348 fdput(f);
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400349 }
Ankit Jain3e63cbb2009-06-19 14:28:07 -0400350 return error;
351}
352
Dominik Brodowskiedf292c2018-03-19 17:46:32 +0100353SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
354{
355 return ksys_fallocate(fd, mode, offset, len);
356}
357
Guo Ren59c10c52022-04-05 15:13:05 +0800358#if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_FALLOCATE)
359COMPAT_SYSCALL_DEFINE6(fallocate, int, fd, int, mode, compat_arg_u64_dual(offset),
360 compat_arg_u64_dual(len))
361{
362 return ksys_fallocate(fd, mode, compat_arg_u64_glue(offset),
363 compat_arg_u64_glue(len));
364}
365#endif
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367/*
368 * access() needs to use the real uid/gid, not the effective uid/gid.
369 * We do this by temporarily clearing all FS-related capabilities and
370 * switching the fsuid/fsgid around to the real ones.
Mateusz Guzik981ee952023-01-25 16:55:57 +0100371 *
372 * Creating new credentials is expensive, so we try to skip doing it,
373 * which we can if the result would match what we already got.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 */
Mateusz Guzik981ee952023-01-25 16:55:57 +0100375static bool access_need_override_creds(int flags)
376{
377 const struct cred *cred;
378
379 if (flags & AT_EACCESS)
380 return false;
381
382 cred = current_cred();
383 if (!uid_eq(cred->fsuid, cred->uid) ||
384 !gid_eq(cred->fsgid, cred->gid))
385 return true;
386
387 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
388 kuid_t root_uid = make_kuid(cred->user_ns, 0);
389 if (!uid_eq(cred->uid, root_uid)) {
390 if (!cap_isclear(cred->cap_effective))
391 return true;
392 } else {
393 if (!cap_isidentical(cred->cap_effective,
394 cred->cap_permitted))
395 return true;
396 }
397 }
398
399 return false;
400}
401
Miklos Szeredi94704512020-05-14 16:44:24 +0200402static const struct cred *access_override_creds(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
David Howellsd84f4f92008-11-14 10:39:23 +1100404 const struct cred *old_cred;
405 struct cred *override_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
David Howellsd84f4f92008-11-14 10:39:23 +1100407 override_cred = prepare_creds();
408 if (!override_cred)
Miklos Szeredi94704512020-05-14 16:44:24 +0200409 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Mateusz Guzik981ee952023-01-25 16:55:57 +0100411 /*
412 * XXX access_need_override_creds performs checks in hopes of skipping
413 * this work. Make sure it stays in sync if making any changes in this
414 * routine.
415 */
416
David Howellsd84f4f92008-11-14 10:39:23 +1100417 override_cred->fsuid = override_cred->uid;
418 override_cred->fsgid = override_cred->gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700420 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
David Howells1cdcbec2008-11-14 10:39:14 +1100421 /* Clear the capabilities if we switch to a non-root user */
Eric W. Biederman18815a12012-02-07 16:45:47 -0800422 kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
423 if (!uid_eq(override_cred->uid, root_uid))
David Howellsd84f4f92008-11-14 10:39:23 +1100424 cap_clear(override_cred->cap_effective);
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700425 else
David Howellsd84f4f92008-11-14 10:39:23 +1100426 override_cred->cap_effective =
427 override_cred->cap_permitted;
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700428 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvaldsd7852fb2019-07-11 09:54:40 -0700430 /*
431 * The new set of credentials can *only* be used in
432 * task-synchronous circumstances, and does not need
433 * RCU freeing, unless somebody then takes a separate
434 * reference to it.
435 *
436 * NOTE! This is _only_ true because this credential
437 * is used purely for override_creds() that installs
438 * it as the subjective cred. Other threads will be
439 * accessing ->real_cred, not the subjective cred.
440 *
441 * If somebody _does_ make a copy of this (using the
442 * 'get_current_cred()' function), that will clear the
443 * non_rcu field, because now that other user may be
444 * expecting RCU freeing. But normal thread-synchronous
445 * cred accesses will keep things non-RCY.
446 */
447 override_cred->non_rcu = 1;
448
David Howellsd84f4f92008-11-14 10:39:23 +1100449 old_cred = override_creds(override_cred);
Miklos Szeredi94704512020-05-14 16:44:24 +0200450
451 /* override_cred() gets its own ref */
452 put_cred(override_cred);
453
454 return old_cred;
455}
456
Christoph Hellwigeb9d7d32020-07-22 11:14:02 +0200457static long do_faccessat(int dfd, const char __user *filename, int mode, int flags)
Miklos Szeredi94704512020-05-14 16:44:24 +0200458{
459 struct path path;
460 struct inode *inode;
461 int res;
462 unsigned int lookup_flags = LOOKUP_FOLLOW;
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200463 const struct cred *old_cred = NULL;
Miklos Szeredi94704512020-05-14 16:44:24 +0200464
465 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
466 return -EINVAL;
467
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200468 if (flags & ~(AT_EACCESS | AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH))
469 return -EINVAL;
470
471 if (flags & AT_SYMLINK_NOFOLLOW)
472 lookup_flags &= ~LOOKUP_FOLLOW;
473 if (flags & AT_EMPTY_PATH)
474 lookup_flags |= LOOKUP_EMPTY;
475
Mateusz Guzik981ee952023-01-25 16:55:57 +0100476 if (access_need_override_creds(flags)) {
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200477 old_cred = access_override_creds();
478 if (!old_cred)
479 return -ENOMEM;
480 }
Miklos Szeredi94704512020-05-14 16:44:24 +0200481
Jeff Layton87fa5592012-12-11 12:10:11 -0500482retry:
483 res = user_path_at(dfd, filename, lookup_flags, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700484 if (res)
485 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
David Howells63afdfc2015-05-06 15:59:00 +0100487 inode = d_backing_inode(path.dentry);
Al Viro256984a2008-07-22 08:09:30 -0400488
489 if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
Al Viro30524472008-07-22 00:02:33 -0400490 /*
491 * MAY_EXEC on regular files is denied if the fs is mounted
492 * with the "noexec" flag.
493 */
494 res = -EACCES;
Eric W. Biederman90f85722015-06-29 14:42:03 -0500495 if (path_noexec(&path))
Al Viro30524472008-07-22 00:02:33 -0400496 goto out_path_release;
497 }
498
Christian Brauner4609e1f2023-01-13 12:49:22 +0100499 res = inode_permission(mnt_idmap(path.mnt), inode, mode | MAY_ACCESS);
Dave Hansen6902d922006-09-30 23:29:01 -0700500 /* SuS v2 requires we report a read only fs too */
Al Viro256984a2008-07-22 08:09:30 -0400501 if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
Dave Hansen6902d922006-09-30 23:29:01 -0700502 goto out_path_release;
Dave Hansen2f676cb2008-02-15 14:37:55 -0800503 /*
504 * This is a rare case where using __mnt_is_readonly()
505 * is OK without a mnt_want/drop_write() pair. Since
506 * no actual write to the fs is performed here, we do
507 * not need to telegraph to that to anyone.
508 *
509 * By doing this, we accept that this access is
510 * inherently racy and know that the fs may change
511 * state before we even see this result.
512 */
Al Viro2d8f3032008-07-22 09:59:21 -0400513 if (__mnt_is_readonly(path.mnt))
Dave Hansen6902d922006-09-30 23:29:01 -0700514 res = -EROFS;
515
516out_path_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400517 path_put(&path);
Jeff Layton87fa5592012-12-11 12:10:11 -0500518 if (retry_estale(res, lookup_flags)) {
519 lookup_flags |= LOOKUP_REVAL;
520 goto retry;
521 }
Dave Hansen6902d922006-09-30 23:29:01 -0700522out:
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200523 if (old_cred)
524 revert_creds(old_cred);
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 return res;
527}
528
Dominik Brodowskicbfe20f2018-03-11 11:34:54 +0100529SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
530{
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200531 return do_faccessat(dfd, filename, mode, 0);
532}
533
534SYSCALL_DEFINE4(faccessat2, int, dfd, const char __user *, filename, int, mode,
535 int, flags)
536{
537 return do_faccessat(dfd, filename, mode, flags);
Dominik Brodowskicbfe20f2018-03-11 11:34:54 +0100538}
539
Heiko Carstensca013e92009-01-14 14:14:19 +0100540SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800541{
Miklos Szeredic8ffd8b2020-05-14 16:44:25 +0200542 return do_faccessat(AT_FDCWD, filename, mode, 0);
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800543}
544
Christoph Hellwigdb63f1e2020-07-22 11:25:21 +0200545SYSCALL_DEFINE1(chdir, const char __user *, filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546{
Al Viro2d8f3032008-07-22 09:59:21 -0400547 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 int error;
Jeff Layton0291c0a2012-12-11 12:10:12 -0500549 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
550retry:
551 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (error)
553 goto out;
554
Christian Brauner02f92b32021-01-21 14:19:22 +0100555 error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (error)
557 goto dput_and_out;
558
Al Viro2d8f3032008-07-22 09:59:21 -0400559 set_fs_pwd(current->fs, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400562 path_put(&path);
Jeff Layton0291c0a2012-12-11 12:10:12 -0500563 if (retry_estale(error, lookup_flags)) {
564 lookup_flags |= LOOKUP_REVAL;
565 goto retry;
566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567out:
568 return error;
569}
570
Heiko Carstens3cdad422009-01-14 14:14:22 +0100571SYSCALL_DEFINE1(fchdir, unsigned int, fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Al Viro2903ff02012-08-28 12:52:22 -0400573 struct fd f = fdget_raw(fd);
Al Viro159b0952017-04-15 15:58:56 -0400574 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 error = -EBADF;
Al Viro2903ff02012-08-28 12:52:22 -0400577 if (!f.file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 goto out;
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 error = -ENOTDIR;
Al Viro159b0952017-04-15 15:58:56 -0400581 if (!d_can_lookup(f.file->f_path.dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 goto out_putf;
583
Christian Brauner02f92b32021-01-21 14:19:22 +0100584 error = file_permission(f.file, MAY_EXEC | MAY_CHDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (!error)
Al Viro2903ff02012-08-28 12:52:22 -0400586 set_fs_pwd(current->fs, &f.file->f_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587out_putf:
Al Viro2903ff02012-08-28 12:52:22 -0400588 fdput(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589out:
590 return error;
591}
592
Christoph Hellwig4b7ca502020-07-22 11:26:13 +0200593SYSCALL_DEFINE1(chroot, const char __user *, filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Al Viro2d8f3032008-07-22 09:59:21 -0400595 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 int error;
Jeff Layton27712612012-12-20 17:08:32 -0500597 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
598retry:
599 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 if (error)
601 goto out;
602
Christian Brauner02f92b32021-01-21 14:19:22 +0100603 error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 if (error)
605 goto dput_and_out;
606
607 error = -EPERM;
Eric W. Biedermanc7b96ac2013-03-20 12:49:49 -0700608 if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 goto dput_and_out;
Tetsuo Handa8b8efb42009-10-04 21:49:48 +0900610 error = security_path_chroot(&path);
611 if (error)
612 goto dput_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Al Viro2d8f3032008-07-22 09:59:21 -0400614 set_fs_root(current->fs, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 error = 0;
616dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400617 path_put(&path);
Jeff Layton27712612012-12-20 17:08:32 -0500618 if (retry_estale(error, lookup_flags)) {
619 lookup_flags |= LOOKUP_REVAL;
620 goto retry;
621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622out:
623 return error;
624}
625
Christoph Hellwig10977422020-07-22 11:41:02 +0200626int chmod_common(const struct path *path, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627{
Al Viroe57712e2011-07-26 04:15:54 -0400628 struct inode *inode = path->dentry->d_inode;
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -0400629 struct inode *delegated_inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 struct iattr newattrs;
Al Viroe57712e2011-07-26 04:15:54 -0400631 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Al Viroe57712e2011-07-26 04:15:54 -0400633 error = mnt_want_write(path->mnt);
634 if (error)
635 return error;
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -0400636retry_deleg:
Al Viro59551022016-01-22 15:40:57 -0500637 inode_lock(inode);
Al Virocdcf1162011-12-08 10:51:53 -0500638 error = security_path_chmod(path, mode);
Al Viroe57712e2011-07-26 04:15:54 -0400639 if (error)
Tetsuo Handafe542cf2009-11-22 11:49:55 +0900640 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
642 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
Christian Braunerabf08572023-01-13 12:49:10 +0100643 error = notify_change(mnt_idmap(path->mnt), path->dentry,
Christian Braunerb8b546a2021-01-21 14:19:35 +0100644 &newattrs, &delegated_inode);
Tetsuo Handafe542cf2009-11-22 11:49:55 +0900645out_unlock:
Al Viro59551022016-01-22 15:40:57 -0500646 inode_unlock(inode);
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -0400647 if (delegated_inode) {
648 error = break_deleg_wait(&delegated_inode);
649 if (!error)
650 goto retry_deleg;
651 }
Al Viroe57712e2011-07-26 04:15:54 -0400652 mnt_drop_write(path->mnt);
653 return error;
654}
655
Christoph Hellwig9e96c8c2020-07-14 08:55:05 +0200656int vfs_fchmod(struct file *file, umode_t mode)
657{
658 audit_file(file);
659 return chmod_common(&file->f_path, mode);
660}
661
Christoph Hellwigb25ba7c2020-07-14 08:59:57 +0200662SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
Al Viroe57712e2011-07-26 04:15:54 -0400663{
Al Viro173c8402013-08-30 12:48:53 -0400664 struct fd f = fdget(fd);
Al Viroe57712e2011-07-26 04:15:54 -0400665 int err = -EBADF;
666
Al Viro173c8402013-08-30 12:48:53 -0400667 if (f.file) {
Christoph Hellwig9e96c8c2020-07-14 08:55:05 +0200668 err = vfs_fchmod(f.file, mode);
Al Viro173c8402013-08-30 12:48:53 -0400669 fdput(f);
Al Viroe57712e2011-07-26 04:15:54 -0400670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 return err;
672}
673
Alexey Gladkov09da0822023-07-11 18:16:04 +0200674static int do_fchmodat(int dfd, const char __user *filename, umode_t mode,
675 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Al Viro2d8f3032008-07-22 09:59:21 -0400677 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 int error;
Alexey Gladkov09da0822023-07-11 18:16:04 +0200679 unsigned int lookup_flags;
680
Aleksa Sarai5daeb412023-07-28 21:58:26 +1000681 if (unlikely(flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)))
Alexey Gladkov09da0822023-07-11 18:16:04 +0200682 return -EINVAL;
683
684 lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
Aleksa Sarai5daeb412023-07-28 21:58:26 +1000685 if (flags & AT_EMPTY_PATH)
686 lookup_flags |= LOOKUP_EMPTY;
Alexey Gladkov09da0822023-07-11 18:16:04 +0200687
Jeff Layton14ff6902012-12-11 12:10:13 -0500688retry:
689 error = user_path_at(dfd, filename, lookup_flags, &path);
Al Viroe57712e2011-07-26 04:15:54 -0400690 if (!error) {
691 error = chmod_common(&path, mode);
692 path_put(&path);
Jeff Layton14ff6902012-12-11 12:10:13 -0500693 if (retry_estale(error, lookup_flags)) {
694 lookup_flags |= LOOKUP_REVAL;
695 goto retry;
696 }
Al Viroe57712e2011-07-26 04:15:54 -0400697 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 return error;
699}
700
Alexey Gladkov09da0822023-07-11 18:16:04 +0200701SYSCALL_DEFINE4(fchmodat2, int, dfd, const char __user *, filename,
702 umode_t, mode, unsigned int, flags)
703{
704 return do_fchmodat(dfd, filename, mode, flags);
705}
706
Dominik Brodowski03450e22018-03-11 11:34:53 +0100707SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename,
708 umode_t, mode)
709{
Alexey Gladkov09da0822023-07-11 18:16:04 +0200710 return do_fchmodat(dfd, filename, mode, 0);
Dominik Brodowski03450e22018-03-11 11:34:53 +0100711}
712
Al Viro49f0a072011-07-26 04:22:01 -0400713SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800714{
Alexey Gladkov09da0822023-07-11 18:16:04 +0200715 return do_fchmodat(AT_FDCWD, filename, mode, 0);
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800716}
717
Anuradha Weeraman55650b22023-05-06 23:59:27 +0530718/*
Christian Braunerb27c82e2022-06-21 16:14:54 +0200719 * Check whether @kuid is valid and if so generate and set vfsuid_t in
720 * ia_vfsuid.
721 *
722 * Return: true if @kuid is valid, false if not.
723 */
724static inline bool setattr_vfsuid(struct iattr *attr, kuid_t kuid)
725{
726 if (!uid_valid(kuid))
727 return false;
728 attr->ia_valid |= ATTR_UID;
729 attr->ia_vfsuid = VFSUIDT_INIT(kuid);
730 return true;
731}
732
Anuradha Weeraman55650b22023-05-06 23:59:27 +0530733/*
Christian Braunerb27c82e2022-06-21 16:14:54 +0200734 * Check whether @kgid is valid and if so generate and set vfsgid_t in
735 * ia_vfsgid.
736 *
737 * Return: true if @kgid is valid, false if not.
738 */
739static inline bool setattr_vfsgid(struct iattr *attr, kgid_t kgid)
740{
741 if (!gid_valid(kgid))
742 return false;
743 attr->ia_valid |= ATTR_GID;
744 attr->ia_vfsgid = VFSGIDT_INIT(kgid);
745 return true;
746}
747
Christoph Hellwigb8734982020-07-22 11:13:26 +0200748int chown_common(const struct path *path, uid_t user, gid_t group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
Christian Braunerabf08572023-01-13 12:49:10 +0100750 struct mnt_idmap *idmap;
Christian Brauner4d7ca402023-01-13 12:49:32 +0100751 struct user_namespace *fs_userns;
Tetsuo Handafe542cf2009-11-22 11:49:55 +0900752 struct inode *inode = path->dentry->d_inode;
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -0400753 struct inode *delegated_inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 int error;
755 struct iattr newattrs;
Eric W. Biederman52137ab2012-03-03 19:52:01 -0800756 kuid_t uid;
757 kgid_t gid;
758
759 uid = make_kuid(current_user_ns(), user);
760 gid = make_kgid(current_user_ns(), group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Christian Braunerabf08572023-01-13 12:49:10 +0100762 idmap = mnt_idmap(path->mnt);
Christian Braunerbd303362021-12-03 12:17:07 +0100763 fs_userns = i_user_ns(inode);
Christian Braunerb8b546a2021-01-21 14:19:35 +0100764
Andrew Elblec1b89402015-02-23 08:51:24 -0500765retry_deleg:
Tetsuo Handaf52d74b2022-09-19 20:05:12 +0900766 newattrs.ia_vfsuid = INVALID_VFSUID;
767 newattrs.ia_vfsgid = INVALID_VFSGID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 newattrs.ia_valid = ATTR_CTIME;
Christian Braunerb27c82e2022-06-21 16:14:54 +0200769 if ((user != (uid_t)-1) && !setattr_vfsuid(&newattrs, uid))
770 return -EINVAL;
771 if ((group != (gid_t)-1) && !setattr_vfsgid(&newattrs, gid))
772 return -EINVAL;
Al Viro59551022016-01-22 15:40:57 -0500773 inode_lock(inode);
Christian Braunered5a7042022-10-17 17:06:37 +0200774 if (!S_ISDIR(inode->i_mode))
775 newattrs.ia_valid |= ATTR_KILL_SUID | ATTR_KILL_PRIV |
Christian Brauner9452e932023-01-13 12:49:27 +0100776 setattr_should_drop_sgid(idmap, inode);
Christian Braunerb27c82e2022-06-21 16:14:54 +0200777 /* Continue to send actual fs values, not the mount values. */
778 error = security_path_chown(
779 path,
Christian Brauner4d7ca402023-01-13 12:49:32 +0100780 from_vfsuid(idmap, fs_userns, newattrs.ia_vfsuid),
781 from_vfsgid(idmap, fs_userns, newattrs.ia_vfsgid));
Tetsuo Handafe542cf2009-11-22 11:49:55 +0900782 if (!error)
Christian Braunerabf08572023-01-13 12:49:10 +0100783 error = notify_change(idmap, path->dentry, &newattrs,
Christian Brauner2f221d62021-01-21 14:19:26 +0100784 &delegated_inode);
Al Viro59551022016-01-22 15:40:57 -0500785 inode_unlock(inode);
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -0400786 if (delegated_inode) {
787 error = break_deleg_wait(&delegated_inode);
788 if (!error)
789 goto retry_deleg;
790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 return error;
792}
793
Dominik Brodowski55731b32018-03-11 11:34:55 +0100794int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
795 int flag)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800796{
Al Viro2d8f3032008-07-22 09:59:21 -0400797 struct path path;
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800798 int error = -EINVAL;
Al Viro65cfc672011-03-13 15:56:26 -0400799 int lookup_flags;
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800800
Al Viro65cfc672011-03-13 15:56:26 -0400801 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800802 goto out;
803
Al Viro65cfc672011-03-13 15:56:26 -0400804 lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
805 if (flag & AT_EMPTY_PATH)
806 lookup_flags |= LOOKUP_EMPTY;
Jeff Layton99a5df32012-12-11 12:10:13 -0500807retry:
Al Viro65cfc672011-03-13 15:56:26 -0400808 error = user_path_at(dfd, filename, lookup_flags, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700809 if (error)
810 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400811 error = mnt_want_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800812 if (error)
813 goto out_release;
Tetsuo Handafe542cf2009-11-22 11:49:55 +0900814 error = chown_common(&path, user, group);
Al Viro2d8f3032008-07-22 09:59:21 -0400815 mnt_drop_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800816out_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400817 path_put(&path);
Jeff Layton99a5df32012-12-11 12:10:13 -0500818 if (retry_estale(error, lookup_flags)) {
819 lookup_flags |= LOOKUP_REVAL;
820 goto retry;
821 }
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800822out:
823 return error;
824}
825
Dominik Brodowski55731b32018-03-11 11:34:55 +0100826SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
827 gid_t, group, int, flag)
828{
829 return do_fchownat(dfd, filename, user, group, flag);
830}
831
David Howells55e4def2012-06-25 12:55:09 +0100832SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
833{
Dominik Brodowski55731b32018-03-11 11:34:55 +0100834 return do_fchownat(AT_FDCWD, filename, user, group, 0);
David Howells55e4def2012-06-25 12:55:09 +0100835}
836
Heiko Carstensca013e92009-01-14 14:14:19 +0100837SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Dominik Brodowski55731b32018-03-11 11:34:55 +0100839 return do_fchownat(AT_FDCWD, filename, user, group,
840 AT_SYMLINK_NOFOLLOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Christoph Hellwigc04011f2020-07-14 08:47:43 +0200843int vfs_fchown(struct file *file, uid_t user, gid_t group)
844{
845 int error;
846
847 error = mnt_want_write_file(file);
848 if (error)
849 return error;
850 audit_file(file);
851 error = chown_common(&file->f_path, user, group);
852 mnt_drop_write_file(file);
853 return error;
854}
855
Dominik Brodowski55731b32018-03-11 11:34:55 +0100856int ksys_fchown(unsigned int fd, uid_t user, gid_t group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
Al Viro2903ff02012-08-28 12:52:22 -0400858 struct fd f = fdget(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 int error = -EBADF;
860
Christoph Hellwigc04011f2020-07-14 08:47:43 +0200861 if (f.file) {
862 error = vfs_fchown(f.file, user, group);
863 fdput(f);
864 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return error;
866}
867
Dominik Brodowski55731b32018-03-11 11:34:55 +0100868SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
869{
870 return ksys_fchown(fd, user, group);
871}
872
Al Viro02e51802012-06-10 14:32:45 -0400873static int do_dentry_open(struct file *f,
David Howells4bacc9c2015-06-18 14:32:31 +0100874 struct inode *inode,
Al Viroae2bb292018-07-10 13:22:28 -0400875 int (*open)(struct inode *, struct file *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
Al Viro1abf0c72011-03-13 03:51:11 -0400877 static const struct file_operations empty_fops = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 int error;
879
Al Virob5bcdda2012-07-20 23:28:46 +0400880 path_get(&f->f_path);
David Howells4bacc9c2015-06-18 14:32:31 +0100881 f->f_inode = inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 f->f_mapping = inode->i_mapping;
Jeff Layton5660e132017-07-06 07:02:25 -0400883 f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
Jeff Layton735e4ae2020-06-01 21:45:36 -0700884 f->f_sb_err = file_sample_sb_err(f);
Jeff Layton5660e132017-07-06 07:02:25 -0400885
Al Viro3f4d5a02014-03-14 09:43:29 -0400886 if (unlikely(f->f_flags & O_PATH)) {
Al Virof5d11402018-07-09 02:35:08 -0400887 f->f_mode = FMODE_PATH | FMODE_OPENED;
Al Viro1abf0c72011-03-13 03:51:11 -0400888 f->f_op = &empty_fops;
Al Viroaf04fad2018-06-02 01:31:02 -0400889 return 0;
Al Viro1abf0c72011-03-13 03:51:11 -0400890 }
891
Amir Goldsteind6da19c2022-08-16 17:53:17 +0300892 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
893 i_readcount_inc(inode);
894 } else if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
Al Viro0ccb2862014-03-14 10:40:46 -0400895 error = get_write_access(inode);
Al Viro3f4d5a02014-03-14 09:43:29 -0400896 if (unlikely(error))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 goto cleanup_file;
Al Viro0ccb2862014-03-14 10:40:46 -0400898 error = __mnt_want_write(f->f_path.mnt);
Al Viro3f4d5a02014-03-14 09:43:29 -0400899 if (unlikely(error)) {
Al Viro0ccb2862014-03-14 10:40:46 -0400900 put_write_access(inode);
901 goto cleanup_file;
902 }
Al Viro83f936c2014-03-14 12:02:47 -0400903 f->f_mode |= FMODE_WRITER;
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -0800904 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Linus Torvalds2be7d342019-11-26 11:34:06 -0800906 /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
907 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
908 f->f_mode |= FMODE_ATOMIC_POS;
909
Al Viro1abf0c72011-03-13 03:51:11 -0400910 f->f_op = fops_get(inode->i_fop);
Denis Efremov7159d542019-09-25 16:49:31 -0700911 if (WARN_ON(!f->f_op)) {
Al Viro72c2d532013-09-22 16:27:52 -0400912 error = -ENODEV;
913 goto cleanup_all;
914 }
Al Viro1abf0c72011-03-13 03:51:11 -0400915
Al Viroe3f20ae2018-07-10 13:25:29 -0400916 error = security_file_open(f);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900917 if (error)
918 goto cleanup_all;
919
Jeff Laytonc65454a2022-11-25 08:48:37 -0500920 error = break_lease(file_inode(f), f->f_flags);
J. Bruce Fieldsf3c7691e2011-09-21 10:58:13 -0400921 if (error)
922 goto cleanup_all;
923
Al Viroea73ea72018-07-11 15:00:04 -0400924 /* normally all 3 are set; ->open() can clear them if needed */
925 f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
Al Viro72c2d532013-09-22 16:27:52 -0400926 if (!open)
Trond Myklebust834f2a42005-10-18 14:20:16 -0700927 open = f->f_op->open;
928 if (open) {
929 error = open(inode, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 if (error)
931 goto cleanup_all;
932 }
Al Virof5d11402018-07-09 02:35:08 -0400933 f->f_mode |= FMODE_OPENED;
Al Viro293bc982014-02-11 18:37:41 -0500934 if ((f->f_mode & FMODE_READ) &&
Al Viro84363182015-04-04 01:14:53 -0400935 likely(f->f_op->read || f->f_op->read_iter))
Al Viro7f7f25e2014-02-11 17:49:24 -0500936 f->f_mode |= FMODE_CAN_READ;
Al Viro293bc982014-02-11 18:37:41 -0500937 if ((f->f_mode & FMODE_WRITE) &&
Al Viro84363182015-04-04 01:14:53 -0400938 likely(f->f_op->write || f->f_op->write_iter))
Al Viro7f7f25e2014-02-11 17:49:24 -0500939 f->f_mode |= FMODE_CAN_WRITE;
Jason A. Donenfelde7478152022-06-29 15:06:57 +0200940 if ((f->f_mode & FMODE_LSEEK) && !f->f_op->llseek)
941 f->f_mode &= ~FMODE_LSEEK;
NeilBrowna2ad63d2022-05-09 18:20:49 -0700942 if (f->f_mapping->a_ops && f->f_mapping->a_ops->direct_IO)
943 f->f_mode |= FMODE_CAN_ODIRECT;
Trond Myklebust834f2a42005-10-18 14:20:16 -0700944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
Al Viro164f40642022-05-22 11:38:11 -0400946 f->f_iocb_flags = iocb_flags(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
948 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
Al Viroaf04fad2018-06-02 01:31:02 -0400949
NeilBrowna2ad63d2022-05-09 18:20:49 -0700950 if ((f->f_flags & O_DIRECT) && !(f->f_mode & FMODE_CAN_ODIRECT))
951 return -EINVAL;
Song Liu09d91cd2019-09-23 15:38:03 -0700952
953 /*
954 * XXX: Huge page cache doesn't support writing yet. Drop all page
955 * cache for this file before processing writes.
956 */
Collin Fijalkovicheb6ecbe2021-06-30 18:51:32 -0700957 if (f->f_mode & FMODE_WRITE) {
958 /*
959 * Paired with smp_mb() in collapse_file() to ensure nr_thps
960 * is up to date and the update to i_writecount by
961 * get_write_access() is visible. Ensures subsequent insertion
962 * of THPs into the page cache will fail.
963 */
964 smp_mb();
Rongwei Wang55fc0d92021-11-05 13:43:41 -0700965 if (filemap_nr_thps(inode->i_mapping)) {
Rongwei Wang8468e932021-11-05 13:43:44 -0700966 struct address_space *mapping = inode->i_mapping;
967
Rongwei Wang55fc0d92021-11-05 13:43:41 -0700968 filemap_invalidate_lock(inode->i_mapping);
Rongwei Wang8468e932021-11-05 13:43:44 -0700969 /*
970 * unmap_mapping_range just need to be called once
971 * here, because the private pages is not need to be
972 * unmapped mapping (e.g. data segment of dynamic
973 * shared libraries here).
974 */
975 unmap_mapping_range(mapping, 0, 0, 0);
976 truncate_inode_pages(mapping, 0);
Rongwei Wang55fc0d92021-11-05 13:43:41 -0700977 filemap_invalidate_unlock(inode->i_mapping);
978 }
Collin Fijalkovicheb6ecbe2021-06-30 18:51:32 -0700979 }
Song Liu09d91cd2019-09-23 15:38:03 -0700980
Amir Goldstein7b8c9d72023-06-11 15:24:29 +0300981 /*
982 * Once we return a file with FMODE_OPENED, __fput() will call
983 * fsnotify_close(), so we need fsnotify_open() here for symmetry.
984 */
985 fsnotify_open(f);
Al Viro96b7e572012-06-10 14:22:04 -0400986 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
988cleanup_all:
Al Viro6b4e8082018-07-08 21:45:07 -0400989 if (WARN_ON_ONCE(error > 0))
990 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 fops_put(f->f_op);
Amir Goldsteind6da19c2022-08-16 17:53:17 +0300992 put_file_access(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993cleanup_file:
Al Viro02e51802012-06-10 14:32:45 -0400994 path_put(&f->f_path);
995 f->f_path.mnt = NULL;
996 f->f_path.dentry = NULL;
Al Virodd379782013-03-01 19:48:30 -0500997 f->f_inode = NULL;
Al Viro96b7e572012-06-10 14:22:04 -0400998 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
Trond Myklebust834f2a42005-10-18 14:20:16 -07001001/**
Miklos Szeredid18e9002012-06-05 15:10:17 +02001002 * finish_open - finish opening a file
Miklos Szeredi0854d452013-09-16 14:51:55 +02001003 * @file: file pointer
Miklos Szeredid18e9002012-06-05 15:10:17 +02001004 * @dentry: pointer to dentry
1005 * @open: open callback
1006 *
1007 * This can be used to finish opening a file passed to i_op->atomic_open().
1008 *
1009 * If the open callback is set to NULL, then the standard f_op->open()
1010 * filesystem callback is substituted.
Miklos Szeredi0854d452013-09-16 14:51:55 +02001011 *
1012 * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
1013 * the return value of d_splice_alias(), then the caller needs to perform dput()
1014 * on it after finish_open().
1015 *
Miklos Szeredi0854d452013-09-16 14:51:55 +02001016 * Returns zero on success or -errno if the open failed.
Miklos Szeredid18e9002012-06-05 15:10:17 +02001017 */
Al Viro30d904942012-06-22 12:40:19 +04001018int finish_open(struct file *file, struct dentry *dentry,
Al Virobe12af32018-06-08 11:44:56 -04001019 int (*open)(struct inode *, struct file *))
Miklos Szeredid18e9002012-06-05 15:10:17 +02001020{
Al Viroaad888f2018-06-08 12:58:04 -04001021 BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */
Miklos Szeredid18e9002012-06-05 15:10:17 +02001022
Al Virob5bcdda2012-07-20 23:28:46 +04001023 file->f_path.dentry = dentry;
Al Viroaad888f2018-06-08 12:58:04 -04001024 return do_dentry_open(file, d_backing_inode(dentry), open);
Miklos Szeredid18e9002012-06-05 15:10:17 +02001025}
1026EXPORT_SYMBOL(finish_open);
1027
1028/**
1029 * finish_no_open - finish ->atomic_open() without opening the file
1030 *
Miklos Szeredi0854d452013-09-16 14:51:55 +02001031 * @file: file pointer
Miklos Szeredid18e9002012-06-05 15:10:17 +02001032 * @dentry: dentry or NULL (as returned from ->lookup())
1033 *
1034 * This can be used to set the result of a successful lookup in ->atomic_open().
Miklos Szeredi0854d452013-09-16 14:51:55 +02001035 *
1036 * NB: unlike finish_open() this function does consume the dentry reference and
1037 * the caller need not dput() it.
1038 *
Al Viro64e1ac42018-07-09 19:17:52 -04001039 * Returns "0" which must be the return value of ->atomic_open() after having
Miklos Szeredi0854d452013-09-16 14:51:55 +02001040 * called this function.
Miklos Szeredid18e9002012-06-05 15:10:17 +02001041 */
Al Viroe45198a2012-06-10 06:48:09 -04001042int finish_no_open(struct file *file, struct dentry *dentry)
Miklos Szeredid18e9002012-06-05 15:10:17 +02001043{
Al Viro30d904942012-06-22 12:40:19 +04001044 file->f_path.dentry = dentry;
Al Viro64e1ac42018-07-09 19:17:52 -04001045 return 0;
Miklos Szeredid18e9002012-06-05 15:10:17 +02001046}
1047EXPORT_SYMBOL(finish_no_open);
1048
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001049char *file_path(struct file *filp, char *buf, int buflen)
1050{
1051 return d_path(&filp->f_path, buf, buflen);
1052}
1053EXPORT_SYMBOL(file_path);
1054
David Howells4bacc9c2015-06-18 14:32:31 +01001055/**
1056 * vfs_open - open the file at the given path
1057 * @path: path to open
1058 * @file: newly allocated file with f_flag initialized
David Howells4bacc9c2015-06-18 14:32:31 +01001059 */
Al Viroae2bb292018-07-10 13:22:28 -04001060int vfs_open(const struct path *path, struct file *file)
David Howells4bacc9c2015-06-18 14:32:31 +01001061{
David Howells4bacc9c2015-06-18 14:32:31 +01001062 file->f_path = *path;
Miklos Szeredia6518f72018-07-06 23:57:06 +02001063 return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
David Howells4bacc9c2015-06-18 14:32:31 +01001064}
1065
Al Viro765927b2012-06-26 21:58:53 +04001066struct file *dentry_open(const struct path *path, int flags,
David Howells745ca242008-11-14 10:39:22 +11001067 const struct cred *cred)
Peter Staubacha1a5b3d2005-09-13 01:25:12 -07001068{
1069 int error;
1070 struct file *f;
1071
David Howellse0e81732009-09-02 09:13:40 +01001072 validate_creds(cred);
1073
Tetsuo Handac212f9a2011-01-19 21:08:41 +09001074 /* We must always pass in a valid mount pointer. */
Al Viro765927b2012-06-26 21:58:53 +04001075 BUG_ON(!path->mnt);
Christoph Hellwig322ee5b2008-02-15 14:37:24 -08001076
Al Viroea73ea72018-07-11 15:00:04 -04001077 f = alloc_empty_file(flags, cred);
Al Viroaf04fad2018-06-02 01:31:02 -04001078 if (!IS_ERR(f)) {
Al Viroae2bb292018-07-10 13:22:28 -04001079 error = vfs_open(path, f);
Al Viro4d27f322018-07-09 11:14:39 -04001080 if (error) {
1081 fput(f);
Al Viroaf04fad2018-06-02 01:31:02 -04001082 f = ERR_PTR(error);
1083 }
Al Viro2a027e72012-06-10 14:24:38 -04001084 }
1085 return f;
Peter Staubacha1a5b3d2005-09-13 01:25:12 -07001086}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087EXPORT_SYMBOL(dentry_open);
1088
Chuck Leverfb70bf12022-03-30 10:30:54 -04001089/**
1090 * dentry_create - Create and open a file
1091 * @path: path to create
1092 * @flags: O_ flags
1093 * @mode: mode bits for new file
1094 * @cred: credentials to use
1095 *
1096 * Caller must hold the parent directory's lock, and have prepared
1097 * a negative dentry, placed in @path->dentry, for the new file.
1098 *
1099 * Caller sets @path->mnt to the vfsmount of the filesystem where
1100 * the new file is to be created. The parent directory and the
1101 * negative dentry must reside on the same filesystem instance.
1102 *
1103 * On success, returns a "struct file *". Otherwise a ERR_PTR
1104 * is returned.
1105 */
1106struct file *dentry_create(const struct path *path, int flags, umode_t mode,
1107 const struct cred *cred)
1108{
1109 struct file *f;
1110 int error;
1111
1112 validate_creds(cred);
1113 f = alloc_empty_file(flags, cred);
1114 if (IS_ERR(f))
1115 return f;
1116
Christian Braunerabf08572023-01-13 12:49:10 +01001117 error = vfs_create(mnt_idmap(path->mnt),
Chuck Leverfb70bf12022-03-30 10:30:54 -04001118 d_inode(path->dentry->d_parent),
1119 path->dentry, mode, true);
1120 if (!error)
1121 error = vfs_open(path, f);
1122
1123 if (unlikely(error)) {
1124 fput(f);
1125 return ERR_PTR(error);
1126 }
1127 return f;
1128}
1129EXPORT_SYMBOL(dentry_create);
1130
Amir Goldsteincbb0b9d2023-06-15 14:22:26 +03001131/**
1132 * kernel_file_open - open a file for kernel internal use
1133 * @path: path of the file to open
1134 * @flags: open flags
1135 * @inode: the inode
1136 * @cred: credentials for open
1137 *
1138 * Open a file for use by in-kernel consumers. The file is not accounted
1139 * against nr_files and must not be installed into the file descriptor
1140 * table.
1141 *
1142 * Return: Opened file on success, an error pointer on failure.
1143 */
1144struct file *kernel_file_open(const struct path *path, int flags,
Al Viro2abc77a2018-07-12 11:18:42 -04001145 struct inode *inode, const struct cred *cred)
1146{
Amir Goldsteincbb0b9d2023-06-15 14:22:26 +03001147 struct file *f;
1148 int error;
Al Viro2abc77a2018-07-12 11:18:42 -04001149
Amir Goldsteincbb0b9d2023-06-15 14:22:26 +03001150 f = alloc_empty_file_noaccount(flags, cred);
1151 if (IS_ERR(f))
1152 return f;
1153
1154 f->f_path = *path;
1155 error = do_dentry_open(f, inode, NULL);
1156 if (error) {
1157 fput(f);
1158 f = ERR_PTR(error);
Al Viro2abc77a2018-07-12 11:18:42 -04001159 }
1160 return f;
1161}
Amir Goldsteincbb0b9d2023-06-15 14:22:26 +03001162EXPORT_SYMBOL_GPL(kernel_file_open);
1163
Amir Goldstein62d53c42023-06-15 14:22:28 +03001164/**
1165 * backing_file_open - open a backing file for kernel internal use
1166 * @path: path of the file to open
1167 * @flags: open flags
Matthew Wilcox (Oracle)35931eb32023-08-18 21:08:24 +01001168 * @real_path: path of the backing file
Amir Goldstein62d53c42023-06-15 14:22:28 +03001169 * @cred: credentials for open
1170 *
1171 * Open a backing file for a stackable filesystem (e.g., overlayfs).
1172 * @path may be on the stackable filesystem and backing inode on the
1173 * underlying filesystem. In this case, we want to be able to return
1174 * the @real_path of the backing inode. This is done by embedding the
1175 * returned file into a container structure that also stores the path of
1176 * the backing inode on the underlying filesystem, which can be
1177 * retrieved using backing_file_real_path().
1178 */
1179struct file *backing_file_open(const struct path *path, int flags,
1180 const struct path *real_path,
1181 const struct cred *cred)
Al Viro2abc77a2018-07-12 11:18:42 -04001182{
Amir Goldstein62d53c42023-06-15 14:22:28 +03001183 struct file *f;
1184 int error;
Al Viro2abc77a2018-07-12 11:18:42 -04001185
Amir Goldstein62d53c42023-06-15 14:22:28 +03001186 f = alloc_empty_backing_file(flags, cred);
1187 if (IS_ERR(f))
1188 return f;
1189
1190 f->f_path = *path;
1191 path_get(real_path);
1192 *backing_file_real_path(f) = *real_path;
1193 error = do_dentry_open(f, d_inode(real_path->dentry), NULL);
1194 if (error) {
1195 fput(f);
1196 f = ERR_PTR(error);
Al Viro2abc77a2018-07-12 11:18:42 -04001197 }
Amir Goldstein62d53c42023-06-15 14:22:28 +03001198
Al Viro2abc77a2018-07-12 11:18:42 -04001199 return f;
1200}
Amir Goldstein62d53c42023-06-15 14:22:28 +03001201EXPORT_SYMBOL_GPL(backing_file_open);
Al Viro2abc77a2018-07-12 11:18:42 -04001202
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001203#define WILL_CREATE(flags) (flags & (O_CREAT | __O_TMPFILE))
1204#define O_PATH_FLAGS (O_DIRECTORY | O_NOFOLLOW | O_PATH | O_CLOEXEC)
1205
Jens Axboe35cb6d52019-12-13 11:10:11 -07001206inline struct open_how build_open_how(int flags, umode_t mode)
Al Viro47c805d2011-02-23 17:44:09 -05001207{
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001208 struct open_how how = {
1209 .flags = flags & VALID_OPEN_FLAGS,
1210 .mode = mode & S_IALLUGO,
1211 };
1212
1213 /* O_PATH beats everything else. */
1214 if (how.flags & O_PATH)
1215 how.flags &= O_PATH_FLAGS;
1216 /* Modes should only be set for create-like flags. */
1217 if (!WILL_CREATE(how.flags))
1218 how.mode = 0;
1219 return how;
1220}
1221
Jens Axboe35cb6d52019-12-13 11:10:11 -07001222inline int build_open_flags(const struct open_how *how, struct open_flags *op)
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001223{
Christian Braunercfe80302021-05-28 11:24:16 +02001224 u64 flags = how->flags;
Min-Hua Chencedd0bd2023-05-03 07:22:08 +08001225 u64 strip = __FMODE_NONOTIFY | O_CLOEXEC;
Al Viro47c805d2011-02-23 17:44:09 -05001226 int lookup_flags = 0;
Al Viro62fb4a12015-12-26 22:33:24 -05001227 int acc_mode = ACC_MODE(flags);
Al Viro47c805d2011-02-23 17:44:09 -05001228
Christian Braunercfe80302021-05-28 11:24:16 +02001229 BUILD_BUG_ON_MSG(upper_32_bits(VALID_OPEN_FLAGS),
1230 "struct open_flags doesn't yet handle flags > 32 bits");
1231
1232 /*
1233 * Strip flags that either shouldn't be set by userspace like
1234 * FMODE_NONOTIFY or that aren't relevant in determining struct
1235 * open_flags like O_CLOEXEC.
1236 */
1237 flags &= ~strip;
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001238
1239 /*
1240 * Older syscalls implicitly clear all of the invalid flags or argument
1241 * values before calling build_open_flags(), but openat2(2) checks all
1242 * of its arguments.
1243 */
1244 if (flags & ~VALID_OPEN_FLAGS)
1245 return -EINVAL;
1246 if (how->resolve & ~VALID_RESOLVE_FLAGS)
1247 return -EINVAL;
1248
Aleksa Sarai398840f2020-10-28 10:50:43 +11001249 /* Scoping flags are mutually exclusive. */
1250 if ((how->resolve & RESOLVE_BENEATH) && (how->resolve & RESOLVE_IN_ROOT))
1251 return -EINVAL;
1252
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001253 /* Deal with the mode. */
1254 if (WILL_CREATE(flags)) {
1255 if (how->mode & ~S_IALLUGO)
1256 return -EINVAL;
1257 op->mode = how->mode | S_IFREG;
1258 } else {
1259 if (how->mode != 0)
1260 return -EINVAL;
1261 op->mode = 0;
1262 }
1263
1264 /*
Christian Brauner43b45062023-03-21 09:18:07 +01001265 * Block bugs where O_DIRECTORY | O_CREAT created regular files.
1266 * Note, that blocking O_DIRECTORY | O_CREAT here also protects
1267 * O_TMPFILE below which requires O_DIRECTORY being raised.
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001268 */
Christian Brauner43b45062023-03-21 09:18:07 +01001269 if ((flags & (O_DIRECTORY | O_CREAT)) == (O_DIRECTORY | O_CREAT))
1270 return -EINVAL;
1271
1272 /* Now handle the creative implementation of O_TMPFILE. */
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001273 if (flags & __O_TMPFILE) {
Christian Brauner43b45062023-03-21 09:18:07 +01001274 /*
1275 * In order to ensure programs get explicit errors when trying
1276 * to use O_TMPFILE on old kernels we enforce that O_DIRECTORY
1277 * is raised alongside __O_TMPFILE.
1278 */
1279 if (!(flags & O_DIRECTORY))
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001280 return -EINVAL;
1281 if (!(acc_mode & MAY_WRITE))
1282 return -EINVAL;
1283 }
1284 if (flags & O_PATH) {
1285 /* O_PATH only permits certain other flags to be set. */
1286 if (flags & ~O_PATH_FLAGS)
1287 return -EINVAL;
1288 acc_mode = 0;
1289 }
Al Viro47c805d2011-02-23 17:44:09 -05001290
1291 /*
1292 * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
1293 * check for O_DSYNC if the need any syncing at all we enforce it's
1294 * always set instead of having to deal with possibly weird behaviour
1295 * for malicious applications setting only __O_SYNC.
1296 */
1297 if (flags & __O_SYNC)
1298 flags |= O_DSYNC;
1299
Al Viro1abf0c72011-03-13 03:51:11 -04001300 op->open_flag = flags;
Al Viro47c805d2011-02-23 17:44:09 -05001301
1302 /* O_TRUNC implies we need access checks for write permissions */
1303 if (flags & O_TRUNC)
1304 acc_mode |= MAY_WRITE;
1305
1306 /* Allow the LSM permission hook to distinguish append
1307 access from general write access. */
1308 if (flags & O_APPEND)
1309 acc_mode |= MAY_APPEND;
1310
1311 op->acc_mode = acc_mode;
1312
Al Viro1abf0c72011-03-13 03:51:11 -04001313 op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
1314
Al Viro47c805d2011-02-23 17:44:09 -05001315 if (flags & O_CREAT) {
1316 op->intent |= LOOKUP_CREATE;
Al Viro31d17262020-01-08 20:19:38 -05001317 if (flags & O_EXCL) {
Al Viro47c805d2011-02-23 17:44:09 -05001318 op->intent |= LOOKUP_EXCL;
Al Viro31d17262020-01-08 20:19:38 -05001319 flags |= O_NOFOLLOW;
1320 }
Al Viro47c805d2011-02-23 17:44:09 -05001321 }
1322
1323 if (flags & O_DIRECTORY)
1324 lookup_flags |= LOOKUP_DIRECTORY;
1325 if (!(flags & O_NOFOLLOW))
1326 lookup_flags |= LOOKUP_FOLLOW;
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001327
1328 if (how->resolve & RESOLVE_NO_XDEV)
1329 lookup_flags |= LOOKUP_NO_XDEV;
1330 if (how->resolve & RESOLVE_NO_MAGICLINKS)
1331 lookup_flags |= LOOKUP_NO_MAGICLINKS;
1332 if (how->resolve & RESOLVE_NO_SYMLINKS)
1333 lookup_flags |= LOOKUP_NO_SYMLINKS;
1334 if (how->resolve & RESOLVE_BENEATH)
1335 lookup_flags |= LOOKUP_BENEATH;
1336 if (how->resolve & RESOLVE_IN_ROOT)
1337 lookup_flags |= LOOKUP_IN_ROOT;
Jens Axboe99668f62020-12-17 09:19:10 -07001338 if (how->resolve & RESOLVE_CACHED) {
1339 /* Don't bother even trying for create/truncate/tmpfile open */
Aleksa Saraia0fc4522023-08-06 02:11:58 +10001340 if (flags & (O_TRUNC | O_CREAT | __O_TMPFILE))
Jens Axboe99668f62020-12-17 09:19:10 -07001341 return -EAGAIN;
1342 lookup_flags |= LOOKUP_CACHED;
1343 }
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001344
Al Virof9652e12013-06-11 08:23:01 +04001345 op->lookup_flags = lookup_flags;
1346 return 0;
Al Viro47c805d2011-02-23 17:44:09 -05001347}
1348
1349/**
Jeff Layton669abf42012-10-10 16:43:10 -04001350 * file_open_name - open file and return file pointer
1351 *
1352 * @name: struct filename containing path to open
1353 * @flags: open flags as per the open(2) second argument
1354 * @mode: mode for the new file if O_CREAT is set, else ignored
1355 *
1356 * This is the helper to open a file from kernelspace if you really
1357 * have to. But in generally you should not do this, so please move
1358 * along, nothing to see here..
1359 */
1360struct file *file_open_name(struct filename *name, int flags, umode_t mode)
1361{
1362 struct open_flags op;
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001363 struct open_how how = build_open_how(flags, mode);
1364 int err = build_open_flags(&how, &op);
1365 if (err)
1366 return ERR_PTR(err);
1367 return do_filp_open(AT_FDCWD, name, &op);
Jeff Layton669abf42012-10-10 16:43:10 -04001368}
1369
1370/**
Al Viro47c805d2011-02-23 17:44:09 -05001371 * filp_open - open file and return file pointer
1372 *
1373 * @filename: path to open
1374 * @flags: open flags as per the open(2) second argument
1375 * @mode: mode for the new file if O_CREAT is set, else ignored
1376 *
1377 * This is the helper to open a file from kernelspace if you really
1378 * have to. But in generally you should not do this, so please move
1379 * along, nothing to see here..
1380 */
Al Viroa218d0f2011-11-21 14:59:34 -05001381struct file *filp_open(const char *filename, int flags, umode_t mode)
Al Viro47c805d2011-02-23 17:44:09 -05001382{
Paul Moore51689102015-01-22 00:00:03 -05001383 struct filename *name = getname_kernel(filename);
1384 struct file *file = ERR_CAST(name);
1385
1386 if (!IS_ERR(name)) {
1387 file = file_open_name(name, flags, mode);
1388 putname(name);
1389 }
1390 return file;
Al Viro47c805d2011-02-23 17:44:09 -05001391}
1392EXPORT_SYMBOL(filp_open);
1393
Al Viroffb37ca2021-04-01 19:00:57 -04001394struct file *file_open_root(const struct path *root,
Jann Horn378c6522016-03-22 14:25:36 -07001395 const char *filename, int flags, umode_t mode)
Al Viro73d049a2011-03-11 12:08:24 -05001396{
1397 struct open_flags op;
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001398 struct open_how how = build_open_how(flags, mode);
1399 int err = build_open_flags(&how, &op);
Al Virof9652e12013-06-11 08:23:01 +04001400 if (err)
1401 return ERR_PTR(err);
Al Viroffb37ca2021-04-01 19:00:57 -04001402 return do_file_open_root(root, filename, &op);
Al Viro73d049a2011-03-11 12:08:24 -05001403}
1404EXPORT_SYMBOL(file_open_root);
1405
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001406static long do_sys_openat2(int dfd, const char __user *filename,
1407 struct open_how *how)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408{
Al Viro47c805d2011-02-23 17:44:09 -05001409 struct open_flags op;
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001410 int fd = build_open_flags(how, &op);
Al Virof9652e12013-06-11 08:23:01 +04001411 struct filename *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
Al Virof9652e12013-06-11 08:23:01 +04001413 if (fd)
1414 return fd;
1415
1416 tmp = getname(filename);
1417 if (IS_ERR(tmp))
1418 return PTR_ERR(tmp);
1419
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001420 fd = get_unused_fd_flags(how->flags);
Al Virof9652e12013-06-11 08:23:01 +04001421 if (fd >= 0) {
1422 struct file *f = do_filp_open(dfd, tmp, &op);
1423 if (IS_ERR(f)) {
1424 put_unused_fd(fd);
1425 fd = PTR_ERR(f);
1426 } else {
Al Virof9652e12013-06-11 08:23:01 +04001427 fd_install(fd, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 }
Al Virof9652e12013-06-11 08:23:01 +04001430 putname(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 return fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432}
Miklos Szeredie922efc2005-09-06 15:18:25 -07001433
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001434long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
1435{
1436 struct open_how how = build_open_how(flags, mode);
1437 return do_sys_openat2(dfd, filename, &how);
1438}
1439
1440
Al Viroa218d0f2011-11-21 14:59:34 -05001441SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
Miklos Szeredie922efc2005-09-06 15:18:25 -07001442{
Christoph Hellwig166e07c2020-06-06 15:03:21 +02001443 if (force_o_largefile())
1444 flags |= O_LARGEFILE;
1445 return do_sys_open(AT_FDCWD, filename, flags, mode);
Miklos Szeredie922efc2005-09-06 15:18:25 -07001446}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Heiko Carstens6559eed82009-01-14 14:14:32 +01001448SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
Al Viroa218d0f2011-11-21 14:59:34 -05001449 umode_t, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001450{
1451 if (force_o_largefile())
1452 flags |= O_LARGEFILE;
Al Viro2cf09662013-01-21 15:25:54 -05001453 return do_sys_open(dfd, filename, flags, mode);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001454}
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001455
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001456SYSCALL_DEFINE4(openat2, int, dfd, const char __user *, filename,
1457 struct open_how __user *, how, size_t, usize)
1458{
1459 int err;
1460 struct open_how tmp;
1461
1462 BUILD_BUG_ON(sizeof(struct open_how) < OPEN_HOW_SIZE_VER0);
1463 BUILD_BUG_ON(sizeof(struct open_how) != OPEN_HOW_SIZE_LATEST);
1464
1465 if (unlikely(usize < OPEN_HOW_SIZE_VER0))
1466 return -EINVAL;
1467
1468 err = copy_struct_from_user(&tmp, sizeof(tmp), how, usize);
1469 if (err)
1470 return err;
1471
Richard Guy Briggs571e5c02021-05-19 16:00:22 -04001472 audit_openat2_how(&tmp);
1473
Aleksa Saraifddb5d42020-01-18 23:07:59 +11001474 /* O_LARGEFILE is only allowed for non-O_PATH. */
1475 if (!(tmp.flags & O_PATH) && force_o_largefile())
1476 tmp.flags |= O_LARGEFILE;
1477
1478 return do_sys_openat2(dfd, filename, &tmp);
1479}
1480
Al Viroe35d49f2017-04-08 18:15:12 -04001481#ifdef CONFIG_COMPAT
1482/*
1483 * Exactly like sys_open(), except that it doesn't set the
1484 * O_LARGEFILE flag.
1485 */
1486COMPAT_SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1487{
1488 return do_sys_open(AT_FDCWD, filename, flags, mode);
1489}
1490
1491/*
1492 * Exactly like sys_openat(), except that it doesn't set the
1493 * O_LARGEFILE flag.
1494 */
1495COMPAT_SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags, umode_t, mode)
1496{
1497 return do_sys_open(dfd, filename, flags, mode);
1498}
1499#endif
1500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501#ifndef __alpha__
1502
1503/*
1504 * For backward compatibility? Maybe this should be moved
1505 * into arch/i386 instead?
1506 */
Al Viroa218d0f2011-11-21 14:59:34 -05001507SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508{
Christoph Hellwig166e07c2020-06-06 15:03:21 +02001509 int flags = O_CREAT | O_WRONLY | O_TRUNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
Christoph Hellwig166e07c2020-06-06 15:03:21 +02001511 if (force_o_largefile())
1512 flags |= O_LARGEFILE;
1513 return do_sys_open(AT_FDCWD, pathname, flags, mode);
1514}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515#endif
1516
1517/*
1518 * "id" is the POSIX thread ID. We use the
1519 * files pointer for this..
1520 */
Linus Torvalds021a1602023-08-08 19:26:35 +02001521static int filp_flush(struct file *filp, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522{
Christoph Lameter45778ca2005-06-23 00:10:17 -07001523 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Jann Horn47d58692023-01-16 20:14:25 +01001525 if (CHECK_DATA_CORRUPTION(file_count(filp) == 0,
1526 "VFS: Close: file count is 0 (f_op=%ps)",
1527 filp->f_op)) {
Christoph Lameter45778ca2005-06-23 00:10:17 -07001528 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 }
1530
Al Viro72c2d532013-09-22 16:27:52 -04001531 if (filp->f_op->flush)
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001532 retval = filp->f_op->flush(filp, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
Al Viro1abf0c72011-03-13 03:51:11 -04001534 if (likely(!(filp->f_mode & FMODE_PATH))) {
1535 dnotify_flush(filp, id);
1536 locks_remove_posix(filp, id);
1537 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 return retval;
1539}
1540
Linus Torvalds021a1602023-08-08 19:26:35 +02001541int filp_close(struct file *filp, fl_owner_t id)
1542{
1543 int retval;
1544
1545 retval = filp_flush(filp, id);
1546 fput(filp);
1547
1548 return retval;
1549}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550EXPORT_SYMBOL(filp_close);
1551
1552/*
1553 * Careful here! We test whether the file pointer is NULL before
1554 * releasing the fd. This ensures that one clone task can't release
1555 * an fd while another clone is opening it.
1556 */
Heiko Carstensca013e92009-01-14 14:14:19 +01001557SYSCALL_DEFINE1(close, unsigned int, fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
Linus Torvalds021a1602023-08-08 19:26:35 +02001559 int retval;
1560 struct file *file;
1561
1562 file = close_fd_get_file(fd);
1563 if (!file)
1564 return -EBADF;
1565
1566 retval = filp_flush(file, current->files);
1567
1568 /*
1569 * We're returning to user space. Don't bother
1570 * with any delayed fput() cases.
1571 */
1572 __fput_sync(file);
Ernie Petridesee731f42006-09-29 02:00:13 -07001573
1574 /* can't restart close syscall because file table entry was cleared */
1575 if (unlikely(retval == -ERESTARTSYS ||
1576 retval == -ERESTARTNOINTR ||
1577 retval == -ERESTARTNOHAND ||
1578 retval == -ERESTART_RESTARTBLOCK))
1579 retval = -EINTR;
1580
1581 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583
Christian Brauner278a5fb2019-05-24 11:30:34 +02001584/**
Matthew Wilcox (Oracle)35931eb32023-08-18 21:08:24 +01001585 * sys_close_range() - Close all file descriptors in a given range.
Christian Brauner278a5fb2019-05-24 11:30:34 +02001586 *
1587 * @fd: starting file descriptor to close
1588 * @max_fd: last file descriptor to close
1589 * @flags: reserved for future extensions
1590 *
1591 * This closes a range of file descriptors. All file descriptors
1592 * from @fd up to and including @max_fd are closed.
1593 * Currently, errors to close a given file descriptor are ignored.
1594 */
1595SYSCALL_DEFINE3(close_range, unsigned int, fd, unsigned int, max_fd,
1596 unsigned int, flags)
1597{
Christian Brauner60997c32020-06-03 21:48:55 +02001598 return __close_range(fd, max_fd, flags);
Christian Brauner278a5fb2019-05-24 11:30:34 +02001599}
1600
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601/*
1602 * This routine simulates a hangup on the tty, to arrange that users
1603 * are given clean terminals at login time.
1604 */
Heiko Carstensca013e92009-01-14 14:14:19 +01001605SYSCALL_DEFINE0(vhangup)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
1607 if (capable(CAP_SYS_TTY_CONFIG)) {
Alan Cox2cb59982008-10-13 10:40:30 +01001608 tty_vhangup_self();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 return 0;
1610 }
1611 return -EPERM;
1612}
1613
1614/*
1615 * Called when an inode is about to be open.
1616 * We use this to disallow opening large files on 32bit systems if
1617 * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1618 * on this flag in sys_open.
1619 */
1620int generic_file_open(struct inode * inode, struct file * filp)
1621{
1622 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
Alan Coxa9c62a12007-10-16 23:30:22 -07001623 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 return 0;
1625}
1626
1627EXPORT_SYMBOL(generic_file_open);
1628
1629/*
1630 * This is used by subsystems that don't want seekable
Dmitry Torokhov06b1e102010-08-10 18:01:33 -07001631 * file descriptors. The function is not supposed to ever fail, the only
1632 * reason it returns an 'int' and not 'void' is so that it can be plugged
1633 * directly into file_operations structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 */
1635int nonseekable_open(struct inode *inode, struct file *filp)
1636{
1637 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1638 return 0;
1639}
1640
1641EXPORT_SYMBOL(nonseekable_open);
Kirill Smelkov10dce8a2019-03-26 22:20:43 +00001642
1643/*
1644 * stream_open is used by subsystems that want stream-like file descriptors.
1645 * Such file descriptors are not seekable and don't have notion of position
Kirill Smelkov438ab722019-04-12 12:31:57 +03001646 * (file.f_pos is always 0 and ppos passed to .read()/.write() is always NULL).
1647 * Contrary to file descriptors of other regular files, .read() and .write()
1648 * can run simultaneously.
Kirill Smelkov10dce8a2019-03-26 22:20:43 +00001649 *
1650 * stream_open never fails and is marked to return int so that it could be
1651 * directly used as file_operations.open .
1652 */
1653int stream_open(struct inode *inode, struct file *filp)
1654{
Linus Torvalds2be7d342019-11-26 11:34:06 -08001655 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS);
Kirill Smelkov10dce8a2019-03-26 22:20:43 +00001656 filp->f_mode |= FMODE_STREAM;
1657 return 0;
1658}
1659
1660EXPORT_SYMBOL(stream_open);