1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
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>
10 #include <linux/file.h>
11 #include <linux/fdtable.h>
12 #include <linux/fsnotify.h>
13 #include <linux/module.h>
14 #include <linux/tty.h>
15 #include <linux/namei.h>
16 #include <linux/backing-dev.h>
17 #include <linux/capability.h>
18 #include <linux/securebits.h>
19 #include <linux/security.h>
20 #include <linux/mount.h>
21 #include <linux/fcntl.h>
22 #include <linux/slab.h>
23 #include <linux/uaccess.h>
24 #include <linux/fs.h>
25 #include <linux/personality.h>
26 #include <linux/pagemap.h>
27 #include <linux/syscalls.h>
28 #include <linux/rcupdate.h>
29 #include <linux/audit.h>
30 #include <linux/falloc.h>
31 #include <linux/fs_struct.h>
32 #include <linux/ima.h>
33 #include <linux/dnotify.h>
34 #include <linux/compat.h>
35 #include <linux/mnt_idmapping.h>
36
37 #include "internal.h"
38 #include <trace/hooks/syscall_check.h>
39
do_truncate(struct user_namespace * mnt_userns,struct dentry * dentry,loff_t length,unsigned int time_attrs,struct file * filp)40 int do_truncate(struct user_namespace *mnt_userns, struct dentry *dentry,
41 loff_t length, unsigned int time_attrs, struct file *filp)
42 {
43 int ret;
44 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;
51 newattrs.ia_valid = ATTR_SIZE | time_attrs;
52 if (filp) {
53 newattrs.ia_file = filp;
54 newattrs.ia_valid |= ATTR_FILE;
55 }
56
57 /* Remove suid, sgid, and file capabilities on truncate too */
58 ret = dentry_needs_remove_privs(mnt_userns, dentry);
59 if (ret < 0)
60 return ret;
61 if (ret)
62 newattrs.ia_valid |= ret | ATTR_FORCE;
63
64 inode_lock(dentry->d_inode);
65 /* Note any delegations or leases have already been broken: */
66 ret = notify_change(mnt_userns, dentry, &newattrs, NULL);
67 inode_unlock(dentry->d_inode);
68 return ret;
69 }
70
vfs_truncate(const struct path * path,loff_t length)71 long vfs_truncate(const struct path *path, loff_t length)
72 {
73 struct user_namespace *mnt_userns;
74 struct inode *inode;
75 long error;
76
77 inode = path->dentry->d_inode;
78
79 /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
80 if (S_ISDIR(inode->i_mode))
81 return -EISDIR;
82 if (!S_ISREG(inode->i_mode))
83 return -EINVAL;
84
85 error = mnt_want_write(path->mnt);
86 if (error)
87 goto out;
88
89 mnt_userns = mnt_user_ns(path->mnt);
90 error = inode_permission(mnt_userns, inode, MAY_WRITE);
91 if (error)
92 goto mnt_drop_write_and_out;
93
94 error = -EPERM;
95 if (IS_APPEND(inode))
96 goto mnt_drop_write_and_out;
97
98 error = get_write_access(inode);
99 if (error)
100 goto mnt_drop_write_and_out;
101
102 /*
103 * Make sure that there are no leases. get_write_access() protects
104 * against the truncate racing with a lease-granting setlease().
105 */
106 error = break_lease(inode, O_WRONLY);
107 if (error)
108 goto put_write_and_out;
109
110 error = security_path_truncate(path);
111 if (!error)
112 error = do_truncate(mnt_userns, path->dentry, length, 0, NULL);
113
114 put_write_and_out:
115 put_write_access(inode);
116 mnt_drop_write_and_out:
117 mnt_drop_write(path->mnt);
118 out:
119 return error;
120 }
121 EXPORT_SYMBOL_GPL(vfs_truncate);
122
do_sys_truncate(const char __user * pathname,loff_t length)123 long do_sys_truncate(const char __user *pathname, loff_t length)
124 {
125 unsigned int lookup_flags = LOOKUP_FOLLOW;
126 struct path path;
127 int error;
128
129 if (length < 0) /* sorry, but loff_t says... */
130 return -EINVAL;
131
132 retry:
133 error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
134 if (!error) {
135 error = vfs_truncate(&path, length);
136 path_put(&path);
137 }
138 if (retry_estale(error, lookup_flags)) {
139 lookup_flags |= LOOKUP_REVAL;
140 goto retry;
141 }
142 return error;
143 }
144
SYSCALL_DEFINE2(truncate,const char __user *,path,long,length)145 SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
146 {
147 return do_sys_truncate(path, length);
148 }
149
150 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(truncate,const char __user *,path,compat_off_t,length)151 COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
152 {
153 return do_sys_truncate(path, length);
154 }
155 #endif
156
do_sys_ftruncate(unsigned int fd,loff_t length,int small)157 long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
158 {
159 struct inode *inode;
160 struct dentry *dentry;
161 struct fd f;
162 int error;
163
164 error = -EINVAL;
165 if (length < 0)
166 goto out;
167 error = -EBADF;
168 f = fdget(fd);
169 if (!f.file)
170 goto out;
171
172 /* explicitly opened as large or we are on 64-bit box */
173 if (f.file->f_flags & O_LARGEFILE)
174 small = 0;
175
176 dentry = f.file->f_path.dentry;
177 inode = dentry->d_inode;
178 error = -EINVAL;
179 if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
180 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;
188 /* Check IS_APPEND on real upper inode */
189 if (IS_APPEND(file_inode(f.file)))
190 goto out_putf;
191 sb_start_write(inode->i_sb);
192 error = security_path_truncate(&f.file->f_path);
193 if (!error)
194 error = do_truncate(file_mnt_user_ns(f.file), dentry, length,
195 ATTR_MTIME | ATTR_CTIME, f.file);
196 sb_end_write(inode->i_sb);
197 out_putf:
198 fdput(f);
199 out:
200 return error;
201 }
202
SYSCALL_DEFINE2(ftruncate,unsigned int,fd,unsigned long,length)203 SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
204 {
205 return do_sys_ftruncate(fd, length, 1);
206 }
207
208 #ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE2(ftruncate,unsigned int,fd,compat_ulong_t,length)209 COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
210 {
211 return do_sys_ftruncate(fd, length, 1);
212 }
213 #endif
214
215 /* LFS versions of truncate are only needed on 32 bit machines */
216 #if BITS_PER_LONG == 32
SYSCALL_DEFINE2(truncate64,const char __user *,path,loff_t,length)217 SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
218 {
219 return do_sys_truncate(path, length);
220 }
221
SYSCALL_DEFINE2(ftruncate64,unsigned int,fd,loff_t,length)222 SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
223 {
224 return do_sys_ftruncate(fd, length, 0);
225 }
226 #endif /* BITS_PER_LONG == 32 */
227
228
vfs_fallocate(struct file * file,int mode,loff_t offset,loff_t len)229 int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
230 {
231 struct inode *inode = file_inode(file);
232 long ret;
233
234 if (offset < 0 || len <= 0)
235 return -EINVAL;
236
237 /* Return error if mode is not supported */
238 if (mode & ~FALLOC_FL_SUPPORTED_MASK)
239 return -EOPNOTSUPP;
240
241 /* Punch hole and zero range are mutually exclusive */
242 if ((mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE)) ==
243 (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE))
244 return -EOPNOTSUPP;
245
246 /* Punch hole must have keep size set */
247 if ((mode & FALLOC_FL_PUNCH_HOLE) &&
248 !(mode & FALLOC_FL_KEEP_SIZE))
249 return -EOPNOTSUPP;
250
251 /* Collapse range should only be used exclusively. */
252 if ((mode & FALLOC_FL_COLLAPSE_RANGE) &&
253 (mode & ~FALLOC_FL_COLLAPSE_RANGE))
254 return -EINVAL;
255
256 /* Insert range should only be used exclusively. */
257 if ((mode & FALLOC_FL_INSERT_RANGE) &&
258 (mode & ~FALLOC_FL_INSERT_RANGE))
259 return -EINVAL;
260
261 /* Unshare range should only be used with allocate mode. */
262 if ((mode & FALLOC_FL_UNSHARE_RANGE) &&
263 (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))
264 return -EINVAL;
265
266 if (!(file->f_mode & FMODE_WRITE))
267 return -EBADF;
268
269 /*
270 * We can only allow pure fallocate on append only files
271 */
272 if ((mode & ~FALLOC_FL_KEEP_SIZE) && IS_APPEND(inode))
273 return -EPERM;
274
275 if (IS_IMMUTABLE(inode))
276 return -EPERM;
277
278 /*
279 * We cannot allow any fallocate operation on an active swapfile
280 */
281 if (IS_SWAPFILE(inode))
282 return -ETXTBSY;
283
284 /*
285 * Revalidate the write permissions, in case security policy has
286 * changed since the files were opened.
287 */
288 ret = security_file_permission(file, MAY_WRITE);
289 if (ret)
290 return ret;
291
292 if (S_ISFIFO(inode->i_mode))
293 return -ESPIPE;
294
295 if (S_ISDIR(inode->i_mode))
296 return -EISDIR;
297
298 if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
299 return -ENODEV;
300
301 /* Check for wrap through zero too */
302 if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
303 return -EFBIG;
304
305 if (!file->f_op->fallocate)
306 return -EOPNOTSUPP;
307
308 file_start_write(file);
309 ret = file->f_op->fallocate(file, mode, offset, len);
310
311 /*
312 * Create inotify and fanotify events.
313 *
314 * To keep the logic simple always create events if fallocate succeeds.
315 * This implies that events are even created if the file size remains
316 * unchanged, e.g. when using flag FALLOC_FL_KEEP_SIZE.
317 */
318 if (ret == 0)
319 fsnotify_modify(file);
320
321 file_end_write(file);
322 return ret;
323 }
324 EXPORT_SYMBOL_GPL(vfs_fallocate);
325
ksys_fallocate(int fd,int mode,loff_t offset,loff_t len)326 int ksys_fallocate(int fd, int mode, loff_t offset, loff_t len)
327 {
328 struct fd f = fdget(fd);
329 int error = -EBADF;
330
331 if (f.file) {
332 error = vfs_fallocate(f.file, mode, offset, len);
333 fdput(f);
334 }
335 return error;
336 }
337
SYSCALL_DEFINE4(fallocate,int,fd,int,mode,loff_t,offset,loff_t,len)338 SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
339 {
340 return ksys_fallocate(fd, mode, offset, len);
341 }
342
343 /*
344 * access() needs to use the real uid/gid, not the effective uid/gid.
345 * We do this by temporarily clearing all FS-related capabilities and
346 * switching the fsuid/fsgid around to the real ones.
347 */
access_override_creds(void)348 static const struct cred *access_override_creds(void)
349 {
350 const struct cred *old_cred;
351 struct cred *override_cred;
352
353 override_cred = prepare_creds();
354 if (!override_cred)
355 return NULL;
356
357 override_cred->fsuid = override_cred->uid;
358 override_cred->fsgid = override_cred->gid;
359
360 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
361 /* Clear the capabilities if we switch to a non-root user */
362 kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
363 if (!uid_eq(override_cred->uid, root_uid))
364 cap_clear(override_cred->cap_effective);
365 else
366 override_cred->cap_effective =
367 override_cred->cap_permitted;
368 }
369
370 /*
371 * The new set of credentials can *only* be used in
372 * task-synchronous circumstances, and does not need
373 * RCU freeing, unless somebody then takes a separate
374 * reference to it.
375 *
376 * NOTE! This is _only_ true because this credential
377 * is used purely for override_creds() that installs
378 * it as the subjective cred. Other threads will be
379 * accessing ->real_cred, not the subjective cred.
380 *
381 * If somebody _does_ make a copy of this (using the
382 * 'get_current_cred()' function), that will clear the
383 * non_rcu field, because now that other user may be
384 * expecting RCU freeing. But normal thread-synchronous
385 * cred accesses will keep things non-RCY.
386 */
387 override_cred->non_rcu = 1;
388
389 old_cred = override_creds(override_cred);
390
391 /* override_cred() gets its own ref */
392 put_cred(override_cred);
393
394 return old_cred;
395 }
396
do_faccessat(int dfd,const char __user * filename,int mode,int flags)397 static long do_faccessat(int dfd, const char __user *filename, int mode, int flags)
398 {
399 struct path path;
400 struct inode *inode;
401 int res;
402 unsigned int lookup_flags = LOOKUP_FOLLOW;
403 const struct cred *old_cred = NULL;
404
405 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
406 return -EINVAL;
407
408 if (flags & ~(AT_EACCESS | AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH))
409 return -EINVAL;
410
411 if (flags & AT_SYMLINK_NOFOLLOW)
412 lookup_flags &= ~LOOKUP_FOLLOW;
413 if (flags & AT_EMPTY_PATH)
414 lookup_flags |= LOOKUP_EMPTY;
415
416 if (!(flags & AT_EACCESS)) {
417 old_cred = access_override_creds();
418 if (!old_cred)
419 return -ENOMEM;
420 }
421
422 retry:
423 res = user_path_at(dfd, filename, lookup_flags, &path);
424 if (res)
425 goto out;
426
427 inode = d_backing_inode(path.dentry);
428
429 if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
430 /*
431 * MAY_EXEC on regular files is denied if the fs is mounted
432 * with the "noexec" flag.
433 */
434 res = -EACCES;
435 if (path_noexec(&path))
436 goto out_path_release;
437 }
438
439 res = inode_permission(mnt_user_ns(path.mnt), inode, mode | MAY_ACCESS);
440 /* SuS v2 requires we report a read only fs too */
441 if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
442 goto out_path_release;
443 /*
444 * This is a rare case where using __mnt_is_readonly()
445 * is OK without a mnt_want/drop_write() pair. Since
446 * no actual write to the fs is performed here, we do
447 * not need to telegraph to that to anyone.
448 *
449 * By doing this, we accept that this access is
450 * inherently racy and know that the fs may change
451 * state before we even see this result.
452 */
453 if (__mnt_is_readonly(path.mnt))
454 res = -EROFS;
455
456 out_path_release:
457 path_put(&path);
458 if (retry_estale(res, lookup_flags)) {
459 lookup_flags |= LOOKUP_REVAL;
460 goto retry;
461 }
462 out:
463 if (old_cred)
464 revert_creds(old_cred);
465
466 return res;
467 }
468
SYSCALL_DEFINE3(faccessat,int,dfd,const char __user *,filename,int,mode)469 SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
470 {
471 return do_faccessat(dfd, filename, mode, 0);
472 }
473
SYSCALL_DEFINE4(faccessat2,int,dfd,const char __user *,filename,int,mode,int,flags)474 SYSCALL_DEFINE4(faccessat2, int, dfd, const char __user *, filename, int, mode,
475 int, flags)
476 {
477 return do_faccessat(dfd, filename, mode, flags);
478 }
479
SYSCALL_DEFINE2(access,const char __user *,filename,int,mode)480 SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
481 {
482 return do_faccessat(AT_FDCWD, filename, mode, 0);
483 }
484
SYSCALL_DEFINE1(chdir,const char __user *,filename)485 SYSCALL_DEFINE1(chdir, const char __user *, filename)
486 {
487 struct path path;
488 int error;
489 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
490 retry:
491 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
492 if (error)
493 goto out;
494
495 error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
496 if (error)
497 goto dput_and_out;
498
499 set_fs_pwd(current->fs, &path);
500
501 dput_and_out:
502 path_put(&path);
503 if (retry_estale(error, lookup_flags)) {
504 lookup_flags |= LOOKUP_REVAL;
505 goto retry;
506 }
507 out:
508 return error;
509 }
510
SYSCALL_DEFINE1(fchdir,unsigned int,fd)511 SYSCALL_DEFINE1(fchdir, unsigned int, fd)
512 {
513 struct fd f = fdget_raw(fd);
514 int error;
515
516 error = -EBADF;
517 if (!f.file)
518 goto out;
519
520 error = -ENOTDIR;
521 if (!d_can_lookup(f.file->f_path.dentry))
522 goto out_putf;
523
524 error = file_permission(f.file, MAY_EXEC | MAY_CHDIR);
525 if (!error)
526 set_fs_pwd(current->fs, &f.file->f_path);
527 out_putf:
528 fdput(f);
529 out:
530 return error;
531 }
532
SYSCALL_DEFINE1(chroot,const char __user *,filename)533 SYSCALL_DEFINE1(chroot, const char __user *, filename)
534 {
535 struct path path;
536 int error;
537 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
538 retry:
539 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
540 if (error)
541 goto out;
542
543 error = path_permission(&path, MAY_EXEC | MAY_CHDIR);
544 if (error)
545 goto dput_and_out;
546
547 error = -EPERM;
548 if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
549 goto dput_and_out;
550 error = security_path_chroot(&path);
551 if (error)
552 goto dput_and_out;
553
554 set_fs_root(current->fs, &path);
555 error = 0;
556 dput_and_out:
557 path_put(&path);
558 if (retry_estale(error, lookup_flags)) {
559 lookup_flags |= LOOKUP_REVAL;
560 goto retry;
561 }
562 out:
563 return error;
564 }
565
chmod_common(const struct path * path,umode_t mode)566 int chmod_common(const struct path *path, umode_t mode)
567 {
568 struct inode *inode = path->dentry->d_inode;
569 struct inode *delegated_inode = NULL;
570 struct iattr newattrs;
571 int error;
572
573 error = mnt_want_write(path->mnt);
574 if (error)
575 return error;
576 retry_deleg:
577 inode_lock(inode);
578 error = security_path_chmod(path, mode);
579 if (error)
580 goto out_unlock;
581 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
582 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
583 error = notify_change(mnt_user_ns(path->mnt), path->dentry,
584 &newattrs, &delegated_inode);
585 out_unlock:
586 inode_unlock(inode);
587 if (delegated_inode) {
588 error = break_deleg_wait(&delegated_inode);
589 if (!error)
590 goto retry_deleg;
591 }
592 mnt_drop_write(path->mnt);
593 return error;
594 }
595
vfs_fchmod(struct file * file,umode_t mode)596 int vfs_fchmod(struct file *file, umode_t mode)
597 {
598 audit_file(file);
599 return chmod_common(&file->f_path, mode);
600 }
601
SYSCALL_DEFINE2(fchmod,unsigned int,fd,umode_t,mode)602 SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
603 {
604 struct fd f = fdget(fd);
605 int err = -EBADF;
606
607 if (f.file) {
608 err = vfs_fchmod(f.file, mode);
609 fdput(f);
610 }
611 return err;
612 }
613
do_fchmodat(int dfd,const char __user * filename,umode_t mode)614 static int do_fchmodat(int dfd, const char __user *filename, umode_t mode)
615 {
616 struct path path;
617 int error;
618 unsigned int lookup_flags = LOOKUP_FOLLOW;
619 retry:
620 error = user_path_at(dfd, filename, lookup_flags, &path);
621 if (!error) {
622 error = chmod_common(&path, mode);
623 path_put(&path);
624 if (retry_estale(error, lookup_flags)) {
625 lookup_flags |= LOOKUP_REVAL;
626 goto retry;
627 }
628 }
629 return error;
630 }
631
SYSCALL_DEFINE3(fchmodat,int,dfd,const char __user *,filename,umode_t,mode)632 SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename,
633 umode_t, mode)
634 {
635 return do_fchmodat(dfd, filename, mode);
636 }
637
SYSCALL_DEFINE2(chmod,const char __user *,filename,umode_t,mode)638 SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
639 {
640 return do_fchmodat(AT_FDCWD, filename, mode);
641 }
642
chown_common(const struct path * path,uid_t user,gid_t group)643 int chown_common(const struct path *path, uid_t user, gid_t group)
644 {
645 struct user_namespace *mnt_userns, *fs_userns;
646 struct inode *inode = path->dentry->d_inode;
647 struct inode *delegated_inode = NULL;
648 int error;
649 struct iattr newattrs;
650 kuid_t uid;
651 kgid_t gid;
652
653 uid = make_kuid(current_user_ns(), user);
654 gid = make_kgid(current_user_ns(), group);
655
656 mnt_userns = mnt_user_ns(path->mnt);
657 fs_userns = i_user_ns(inode);
658 uid = mapped_kuid_user(mnt_userns, fs_userns, uid);
659 gid = mapped_kgid_user(mnt_userns, fs_userns, gid);
660
661 retry_deleg:
662 newattrs.ia_valid = ATTR_CTIME;
663 if (user != (uid_t) -1) {
664 if (!uid_valid(uid))
665 return -EINVAL;
666 newattrs.ia_valid |= ATTR_UID;
667 newattrs.ia_uid = uid;
668 }
669 if (group != (gid_t) -1) {
670 if (!gid_valid(gid))
671 return -EINVAL;
672 newattrs.ia_valid |= ATTR_GID;
673 newattrs.ia_gid = gid;
674 }
675 inode_lock(inode);
676 if (!S_ISDIR(inode->i_mode))
677 newattrs.ia_valid |= ATTR_KILL_SUID | ATTR_KILL_PRIV |
678 setattr_should_drop_sgid(mnt_userns, inode);
679 error = security_path_chown(path, uid, gid);
680 if (!error)
681 error = notify_change(mnt_userns, path->dentry, &newattrs,
682 &delegated_inode);
683 inode_unlock(inode);
684 if (delegated_inode) {
685 error = break_deleg_wait(&delegated_inode);
686 if (!error)
687 goto retry_deleg;
688 }
689 return error;
690 }
691
do_fchownat(int dfd,const char __user * filename,uid_t user,gid_t group,int flag)692 int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
693 int flag)
694 {
695 struct path path;
696 int error = -EINVAL;
697 int lookup_flags;
698
699 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
700 goto out;
701
702 lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
703 if (flag & AT_EMPTY_PATH)
704 lookup_flags |= LOOKUP_EMPTY;
705 retry:
706 error = user_path_at(dfd, filename, lookup_flags, &path);
707 if (error)
708 goto out;
709 error = mnt_want_write(path.mnt);
710 if (error)
711 goto out_release;
712 error = chown_common(&path, user, group);
713 mnt_drop_write(path.mnt);
714 out_release:
715 path_put(&path);
716 if (retry_estale(error, lookup_flags)) {
717 lookup_flags |= LOOKUP_REVAL;
718 goto retry;
719 }
720 out:
721 return error;
722 }
723
SYSCALL_DEFINE5(fchownat,int,dfd,const char __user *,filename,uid_t,user,gid_t,group,int,flag)724 SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
725 gid_t, group, int, flag)
726 {
727 return do_fchownat(dfd, filename, user, group, flag);
728 }
729
SYSCALL_DEFINE3(chown,const char __user *,filename,uid_t,user,gid_t,group)730 SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
731 {
732 return do_fchownat(AT_FDCWD, filename, user, group, 0);
733 }
734
SYSCALL_DEFINE3(lchown,const char __user *,filename,uid_t,user,gid_t,group)735 SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
736 {
737 return do_fchownat(AT_FDCWD, filename, user, group,
738 AT_SYMLINK_NOFOLLOW);
739 }
740
vfs_fchown(struct file * file,uid_t user,gid_t group)741 int vfs_fchown(struct file *file, uid_t user, gid_t group)
742 {
743 int error;
744
745 error = mnt_want_write_file(file);
746 if (error)
747 return error;
748 audit_file(file);
749 error = chown_common(&file->f_path, user, group);
750 mnt_drop_write_file(file);
751 return error;
752 }
753
ksys_fchown(unsigned int fd,uid_t user,gid_t group)754 int ksys_fchown(unsigned int fd, uid_t user, gid_t group)
755 {
756 struct fd f = fdget(fd);
757 int error = -EBADF;
758
759 if (f.file) {
760 error = vfs_fchown(f.file, user, group);
761 fdput(f);
762 }
763 return error;
764 }
765
SYSCALL_DEFINE3(fchown,unsigned int,fd,uid_t,user,gid_t,group)766 SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
767 {
768 return ksys_fchown(fd, user, group);
769 }
770
do_dentry_open(struct file * f,struct inode * inode,int (* open)(struct inode *,struct file *))771 static int do_dentry_open(struct file *f,
772 struct inode *inode,
773 int (*open)(struct inode *, struct file *))
774 {
775 static const struct file_operations empty_fops = {};
776 int error;
777
778 path_get(&f->f_path);
779 f->f_inode = inode;
780 f->f_mapping = inode->i_mapping;
781 f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
782 f->f_sb_err = file_sample_sb_err(f);
783
784 if (unlikely(f->f_flags & O_PATH)) {
785 f->f_mode = FMODE_PATH | FMODE_OPENED;
786 f->f_op = &empty_fops;
787 return 0;
788 }
789
790 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
791 i_readcount_inc(inode);
792 } else if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
793 error = get_write_access(inode);
794 if (unlikely(error))
795 goto cleanup_file;
796 error = __mnt_want_write(f->f_path.mnt);
797 if (unlikely(error)) {
798 put_write_access(inode);
799 goto cleanup_file;
800 }
801 f->f_mode |= FMODE_WRITER;
802 }
803
804 /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
805 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
806 f->f_mode |= FMODE_ATOMIC_POS;
807
808 f->f_op = fops_get(inode->i_fop);
809 if (WARN_ON(!f->f_op)) {
810 error = -ENODEV;
811 goto cleanup_all;
812 }
813 trace_android_vh_check_file_open(f);
814
815 error = security_file_open(f);
816 if (error)
817 goto cleanup_all;
818
819 error = break_lease(locks_inode(f), f->f_flags);
820 if (error)
821 goto cleanup_all;
822
823 /* normally all 3 are set; ->open() can clear them if needed */
824 f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
825 if (!open)
826 open = f->f_op->open;
827 if (open) {
828 error = open(inode, f);
829 if (error)
830 goto cleanup_all;
831 }
832 f->f_mode |= FMODE_OPENED;
833 if ((f->f_mode & FMODE_READ) &&
834 likely(f->f_op->read || f->f_op->read_iter))
835 f->f_mode |= FMODE_CAN_READ;
836 if ((f->f_mode & FMODE_WRITE) &&
837 likely(f->f_op->write || f->f_op->write_iter))
838 f->f_mode |= FMODE_CAN_WRITE;
839
840 f->f_write_hint = WRITE_LIFE_NOT_SET;
841 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
842
843 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
844
845 /* NB: we're sure to have correct a_ops only after f_op->open */
846 if (f->f_flags & O_DIRECT) {
847 if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO)
848 return -EINVAL;
849 }
850
851 /*
852 * XXX: Huge page cache doesn't support writing yet. Drop all page
853 * cache for this file before processing writes.
854 */
855 if (f->f_mode & FMODE_WRITE) {
856 /*
857 * Paired with smp_mb() in collapse_file() to ensure nr_thps
858 * is up to date and the update to i_writecount by
859 * get_write_access() is visible. Ensures subsequent insertion
860 * of THPs into the page cache will fail.
861 */
862 smp_mb();
863 if (filemap_nr_thps(inode->i_mapping)) {
864 struct address_space *mapping = inode->i_mapping;
865
866 filemap_invalidate_lock(inode->i_mapping);
867 /*
868 * unmap_mapping_range just need to be called once
869 * here, because the private pages is not need to be
870 * unmapped mapping (e.g. data segment of dynamic
871 * shared libraries here).
872 */
873 unmap_mapping_range(mapping, 0, 0, 0);
874 truncate_inode_pages(mapping, 0);
875 filemap_invalidate_unlock(inode->i_mapping);
876 }
877 }
878
879 return 0;
880
881 cleanup_all:
882 if (WARN_ON_ONCE(error > 0))
883 error = -EINVAL;
884 fops_put(f->f_op);
885 put_file_access(f);
886 cleanup_file:
887 path_put(&f->f_path);
888 f->f_path.mnt = NULL;
889 f->f_path.dentry = NULL;
890 f->f_inode = NULL;
891 return error;
892 }
893
894 /**
895 * finish_open - finish opening a file
896 * @file: file pointer
897 * @dentry: pointer to dentry
898 * @open: open callback
899 * @opened: state of open
900 *
901 * This can be used to finish opening a file passed to i_op->atomic_open().
902 *
903 * If the open callback is set to NULL, then the standard f_op->open()
904 * filesystem callback is substituted.
905 *
906 * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
907 * the return value of d_splice_alias(), then the caller needs to perform dput()
908 * on it after finish_open().
909 *
910 * Returns zero on success or -errno if the open failed.
911 */
finish_open(struct file * file,struct dentry * dentry,int (* open)(struct inode *,struct file *))912 int finish_open(struct file *file, struct dentry *dentry,
913 int (*open)(struct inode *, struct file *))
914 {
915 BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */
916
917 file->f_path.dentry = dentry;
918 return do_dentry_open(file, d_backing_inode(dentry), open);
919 }
920 EXPORT_SYMBOL(finish_open);
921
922 /**
923 * finish_no_open - finish ->atomic_open() without opening the file
924 *
925 * @file: file pointer
926 * @dentry: dentry or NULL (as returned from ->lookup())
927 *
928 * This can be used to set the result of a successful lookup in ->atomic_open().
929 *
930 * NB: unlike finish_open() this function does consume the dentry reference and
931 * the caller need not dput() it.
932 *
933 * Returns "0" which must be the return value of ->atomic_open() after having
934 * called this function.
935 */
finish_no_open(struct file * file,struct dentry * dentry)936 int finish_no_open(struct file *file, struct dentry *dentry)
937 {
938 file->f_path.dentry = dentry;
939 return 0;
940 }
941 EXPORT_SYMBOL(finish_no_open);
942
file_path(struct file * filp,char * buf,int buflen)943 char *file_path(struct file *filp, char *buf, int buflen)
944 {
945 return d_path(&filp->f_path, buf, buflen);
946 }
947 EXPORT_SYMBOL(file_path);
948
949 /**
950 * vfs_open - open the file at the given path
951 * @path: path to open
952 * @file: newly allocated file with f_flag initialized
953 * @cred: credentials to use
954 */
vfs_open(const struct path * path,struct file * file)955 int vfs_open(const struct path *path, struct file *file)
956 {
957 file->f_path = *path;
958 return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
959 }
960
dentry_open(const struct path * path,int flags,const struct cred * cred)961 struct file *dentry_open(const struct path *path, int flags,
962 const struct cred *cred)
963 {
964 int error;
965 struct file *f;
966
967 validate_creds(cred);
968
969 /* We must always pass in a valid mount pointer. */
970 BUG_ON(!path->mnt);
971
972 f = alloc_empty_file(flags, cred);
973 if (!IS_ERR(f)) {
974 error = vfs_open(path, f);
975 if (error) {
976 fput(f);
977 f = ERR_PTR(error);
978 }
979 }
980 return f;
981 }
982 EXPORT_SYMBOL_NS(dentry_open, ANDROID_GKI_VFS_EXPORT_ONLY);
983
open_with_fake_path(const struct path * path,int flags,struct inode * inode,const struct cred * cred)984 struct file *open_with_fake_path(const struct path *path, int flags,
985 struct inode *inode, const struct cred *cred)
986 {
987 struct file *f = alloc_empty_file_noaccount(flags, cred);
988 if (!IS_ERR(f)) {
989 int error;
990
991 f->f_path = *path;
992 error = do_dentry_open(f, inode, NULL);
993 if (error) {
994 fput(f);
995 f = ERR_PTR(error);
996 }
997 }
998 return f;
999 }
1000 EXPORT_SYMBOL(open_with_fake_path);
1001
1002 #define WILL_CREATE(flags) (flags & (O_CREAT | __O_TMPFILE))
1003 #define O_PATH_FLAGS (O_DIRECTORY | O_NOFOLLOW | O_PATH | O_CLOEXEC)
1004
build_open_how(int flags,umode_t mode)1005 inline struct open_how build_open_how(int flags, umode_t mode)
1006 {
1007 struct open_how how = {
1008 .flags = flags & VALID_OPEN_FLAGS,
1009 .mode = mode & S_IALLUGO,
1010 };
1011
1012 /* O_PATH beats everything else. */
1013 if (how.flags & O_PATH)
1014 how.flags &= O_PATH_FLAGS;
1015 /* Modes should only be set for create-like flags. */
1016 if (!WILL_CREATE(how.flags))
1017 how.mode = 0;
1018 return how;
1019 }
1020
build_open_flags(const struct open_how * how,struct open_flags * op)1021 inline int build_open_flags(const struct open_how *how, struct open_flags *op)
1022 {
1023 u64 flags = how->flags;
1024 u64 strip = FMODE_NONOTIFY | O_CLOEXEC;
1025 int lookup_flags = 0;
1026 int acc_mode = ACC_MODE(flags);
1027
1028 BUILD_BUG_ON_MSG(upper_32_bits(VALID_OPEN_FLAGS),
1029 "struct open_flags doesn't yet handle flags > 32 bits");
1030
1031 /*
1032 * Strip flags that either shouldn't be set by userspace like
1033 * FMODE_NONOTIFY or that aren't relevant in determining struct
1034 * open_flags like O_CLOEXEC.
1035 */
1036 flags &= ~strip;
1037
1038 /*
1039 * Older syscalls implicitly clear all of the invalid flags or argument
1040 * values before calling build_open_flags(), but openat2(2) checks all
1041 * of its arguments.
1042 */
1043 if (flags & ~VALID_OPEN_FLAGS)
1044 return -EINVAL;
1045 if (how->resolve & ~VALID_RESOLVE_FLAGS)
1046 return -EINVAL;
1047
1048 /* Scoping flags are mutually exclusive. */
1049 if ((how->resolve & RESOLVE_BENEATH) && (how->resolve & RESOLVE_IN_ROOT))
1050 return -EINVAL;
1051
1052 /* Deal with the mode. */
1053 if (WILL_CREATE(flags)) {
1054 if (how->mode & ~S_IALLUGO)
1055 return -EINVAL;
1056 op->mode = how->mode | S_IFREG;
1057 } else {
1058 if (how->mode != 0)
1059 return -EINVAL;
1060 op->mode = 0;
1061 }
1062
1063 /*
1064 * In order to ensure programs get explicit errors when trying to use
1065 * O_TMPFILE on old kernels, O_TMPFILE is implemented such that it
1066 * looks like (O_DIRECTORY|O_RDWR & ~O_CREAT) to old kernels. But we
1067 * have to require userspace to explicitly set it.
1068 */
1069 if (flags & __O_TMPFILE) {
1070 if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
1071 return -EINVAL;
1072 if (!(acc_mode & MAY_WRITE))
1073 return -EINVAL;
1074 }
1075 if (flags & O_PATH) {
1076 /* O_PATH only permits certain other flags to be set. */
1077 if (flags & ~O_PATH_FLAGS)
1078 return -EINVAL;
1079 acc_mode = 0;
1080 }
1081
1082 /*
1083 * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
1084 * check for O_DSYNC if the need any syncing at all we enforce it's
1085 * always set instead of having to deal with possibly weird behaviour
1086 * for malicious applications setting only __O_SYNC.
1087 */
1088 if (flags & __O_SYNC)
1089 flags |= O_DSYNC;
1090
1091 op->open_flag = flags;
1092
1093 /* O_TRUNC implies we need access checks for write permissions */
1094 if (flags & O_TRUNC)
1095 acc_mode |= MAY_WRITE;
1096
1097 /* Allow the LSM permission hook to distinguish append
1098 access from general write access. */
1099 if (flags & O_APPEND)
1100 acc_mode |= MAY_APPEND;
1101
1102 op->acc_mode = acc_mode;
1103
1104 op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
1105
1106 if (flags & O_CREAT) {
1107 op->intent |= LOOKUP_CREATE;
1108 if (flags & O_EXCL) {
1109 op->intent |= LOOKUP_EXCL;
1110 flags |= O_NOFOLLOW;
1111 }
1112 }
1113
1114 if (flags & O_DIRECTORY)
1115 lookup_flags |= LOOKUP_DIRECTORY;
1116 if (!(flags & O_NOFOLLOW))
1117 lookup_flags |= LOOKUP_FOLLOW;
1118
1119 if (how->resolve & RESOLVE_NO_XDEV)
1120 lookup_flags |= LOOKUP_NO_XDEV;
1121 if (how->resolve & RESOLVE_NO_MAGICLINKS)
1122 lookup_flags |= LOOKUP_NO_MAGICLINKS;
1123 if (how->resolve & RESOLVE_NO_SYMLINKS)
1124 lookup_flags |= LOOKUP_NO_SYMLINKS;
1125 if (how->resolve & RESOLVE_BENEATH)
1126 lookup_flags |= LOOKUP_BENEATH;
1127 if (how->resolve & RESOLVE_IN_ROOT)
1128 lookup_flags |= LOOKUP_IN_ROOT;
1129 if (how->resolve & RESOLVE_CACHED) {
1130 /* Don't bother even trying for create/truncate/tmpfile open */
1131 if (flags & (O_TRUNC | O_CREAT | __O_TMPFILE))
1132 return -EAGAIN;
1133 lookup_flags |= LOOKUP_CACHED;
1134 }
1135
1136 op->lookup_flags = lookup_flags;
1137 return 0;
1138 }
1139
1140 /**
1141 * file_open_name - open file and return file pointer
1142 *
1143 * @name: struct filename containing path to open
1144 * @flags: open flags as per the open(2) second argument
1145 * @mode: mode for the new file if O_CREAT is set, else ignored
1146 *
1147 * This is the helper to open a file from kernelspace if you really
1148 * have to. But in generally you should not do this, so please move
1149 * along, nothing to see here..
1150 */
file_open_name(struct filename * name,int flags,umode_t mode)1151 struct file *file_open_name(struct filename *name, int flags, umode_t mode)
1152 {
1153 struct open_flags op;
1154 struct open_how how = build_open_how(flags, mode);
1155 int err = build_open_flags(&how, &op);
1156 if (err)
1157 return ERR_PTR(err);
1158 return do_filp_open(AT_FDCWD, name, &op);
1159 }
1160
1161 /**
1162 * filp_open - open file and return file pointer
1163 *
1164 * @filename: path to open
1165 * @flags: open flags as per the open(2) second argument
1166 * @mode: mode for the new file if O_CREAT is set, else ignored
1167 *
1168 * This is the helper to open a file from kernelspace if you really
1169 * have to. But in generally you should not do this, so please move
1170 * along, nothing to see here..
1171 */
filp_open(const char * filename,int flags,umode_t mode)1172 struct file *filp_open(const char *filename, int flags, umode_t mode)
1173 {
1174 struct filename *name = getname_kernel(filename);
1175 struct file *file = ERR_CAST(name);
1176
1177 if (!IS_ERR(name)) {
1178 file = file_open_name(name, flags, mode);
1179 putname(name);
1180 }
1181 return file;
1182 }
1183 EXPORT_SYMBOL_NS(filp_open, ANDROID_GKI_VFS_EXPORT_ONLY);
1184
1185
1186 /* ANDROID: Allow drivers to open only block files from kernel mode */
filp_open_block(const char * filename,int flags,umode_t mode)1187 struct file *filp_open_block(const char *filename, int flags, umode_t mode)
1188 {
1189 struct file *file;
1190
1191 file = filp_open(filename, flags, mode);
1192 if (IS_ERR(file))
1193 goto err_out;
1194
1195 /* Drivers should only be allowed to open block devices */
1196 if (!S_ISBLK(file->f_mapping->host->i_mode)) {
1197 filp_close(file, NULL);
1198 file = ERR_PTR(-ENOTBLK);
1199 }
1200
1201 err_out:
1202 return file;
1203 }
1204 EXPORT_SYMBOL_GPL(filp_open_block);
1205
file_open_root(const struct path * root,const char * filename,int flags,umode_t mode)1206 struct file *file_open_root(const struct path *root,
1207 const char *filename, int flags, umode_t mode)
1208 {
1209 struct open_flags op;
1210 struct open_how how = build_open_how(flags, mode);
1211 int err = build_open_flags(&how, &op);
1212 if (err)
1213 return ERR_PTR(err);
1214 return do_file_open_root(root, filename, &op);
1215 }
1216 EXPORT_SYMBOL(file_open_root);
1217
do_sys_openat2(int dfd,const char __user * filename,struct open_how * how)1218 static long do_sys_openat2(int dfd, const char __user *filename,
1219 struct open_how *how)
1220 {
1221 struct open_flags op;
1222 int fd = build_open_flags(how, &op);
1223 struct filename *tmp;
1224
1225 if (fd)
1226 return fd;
1227
1228 tmp = getname(filename);
1229 if (IS_ERR(tmp))
1230 return PTR_ERR(tmp);
1231
1232 fd = get_unused_fd_flags(how->flags);
1233 if (fd >= 0) {
1234 struct file *f = do_filp_open(dfd, tmp, &op);
1235 if (IS_ERR(f)) {
1236 put_unused_fd(fd);
1237 fd = PTR_ERR(f);
1238 } else {
1239 fsnotify_open(f);
1240 fd_install(fd, f);
1241 }
1242 }
1243 putname(tmp);
1244 return fd;
1245 }
1246
do_sys_open(int dfd,const char __user * filename,int flags,umode_t mode)1247 long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
1248 {
1249 struct open_how how = build_open_how(flags, mode);
1250 return do_sys_openat2(dfd, filename, &how);
1251 }
1252
1253
SYSCALL_DEFINE3(open,const char __user *,filename,int,flags,umode_t,mode)1254 SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1255 {
1256 if (force_o_largefile())
1257 flags |= O_LARGEFILE;
1258 return do_sys_open(AT_FDCWD, filename, flags, mode);
1259 }
1260
SYSCALL_DEFINE4(openat,int,dfd,const char __user *,filename,int,flags,umode_t,mode)1261 SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1262 umode_t, mode)
1263 {
1264 if (force_o_largefile())
1265 flags |= O_LARGEFILE;
1266 return do_sys_open(dfd, filename, flags, mode);
1267 }
1268
SYSCALL_DEFINE4(openat2,int,dfd,const char __user *,filename,struct open_how __user *,how,size_t,usize)1269 SYSCALL_DEFINE4(openat2, int, dfd, const char __user *, filename,
1270 struct open_how __user *, how, size_t, usize)
1271 {
1272 int err;
1273 struct open_how tmp;
1274
1275 BUILD_BUG_ON(sizeof(struct open_how) < OPEN_HOW_SIZE_VER0);
1276 BUILD_BUG_ON(sizeof(struct open_how) != OPEN_HOW_SIZE_LATEST);
1277
1278 if (unlikely(usize < OPEN_HOW_SIZE_VER0))
1279 return -EINVAL;
1280
1281 err = copy_struct_from_user(&tmp, sizeof(tmp), how, usize);
1282 if (err)
1283 return err;
1284
1285 /* O_LARGEFILE is only allowed for non-O_PATH. */
1286 if (!(tmp.flags & O_PATH) && force_o_largefile())
1287 tmp.flags |= O_LARGEFILE;
1288
1289 return do_sys_openat2(dfd, filename, &tmp);
1290 }
1291
1292 #ifdef CONFIG_COMPAT
1293 /*
1294 * Exactly like sys_open(), except that it doesn't set the
1295 * O_LARGEFILE flag.
1296 */
COMPAT_SYSCALL_DEFINE3(open,const char __user *,filename,int,flags,umode_t,mode)1297 COMPAT_SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1298 {
1299 return do_sys_open(AT_FDCWD, filename, flags, mode);
1300 }
1301
1302 /*
1303 * Exactly like sys_openat(), except that it doesn't set the
1304 * O_LARGEFILE flag.
1305 */
COMPAT_SYSCALL_DEFINE4(openat,int,dfd,const char __user *,filename,int,flags,umode_t,mode)1306 COMPAT_SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags, umode_t, mode)
1307 {
1308 return do_sys_open(dfd, filename, flags, mode);
1309 }
1310 #endif
1311
1312 #ifndef __alpha__
1313
1314 /*
1315 * For backward compatibility? Maybe this should be moved
1316 * into arch/i386 instead?
1317 */
SYSCALL_DEFINE2(creat,const char __user *,pathname,umode_t,mode)1318 SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1319 {
1320 int flags = O_CREAT | O_WRONLY | O_TRUNC;
1321
1322 if (force_o_largefile())
1323 flags |= O_LARGEFILE;
1324 return do_sys_open(AT_FDCWD, pathname, flags, mode);
1325 }
1326 #endif
1327
1328 /*
1329 * "id" is the POSIX thread ID. We use the
1330 * files pointer for this..
1331 */
filp_close(struct file * filp,fl_owner_t id)1332 int filp_close(struct file *filp, fl_owner_t id)
1333 {
1334 int retval = 0;
1335
1336 if (!file_count(filp)) {
1337 printk(KERN_ERR "VFS: Close: file count is 0\n");
1338 return 0;
1339 }
1340
1341 if (filp->f_op->flush)
1342 retval = filp->f_op->flush(filp, id);
1343
1344 if (likely(!(filp->f_mode & FMODE_PATH))) {
1345 dnotify_flush(filp, id);
1346 locks_remove_posix(filp, id);
1347 }
1348 fput(filp);
1349 return retval;
1350 }
1351
1352 EXPORT_SYMBOL(filp_close);
1353
1354 /*
1355 * Careful here! We test whether the file pointer is NULL before
1356 * releasing the fd. This ensures that one clone task can't release
1357 * an fd while another clone is opening it.
1358 */
SYSCALL_DEFINE1(close,unsigned int,fd)1359 SYSCALL_DEFINE1(close, unsigned int, fd)
1360 {
1361 int retval = close_fd(fd);
1362
1363 /* can't restart close syscall because file table entry was cleared */
1364 if (unlikely(retval == -ERESTARTSYS ||
1365 retval == -ERESTARTNOINTR ||
1366 retval == -ERESTARTNOHAND ||
1367 retval == -ERESTART_RESTARTBLOCK))
1368 retval = -EINTR;
1369
1370 return retval;
1371 }
1372
1373 /**
1374 * close_range() - Close all file descriptors in a given range.
1375 *
1376 * @fd: starting file descriptor to close
1377 * @max_fd: last file descriptor to close
1378 * @flags: reserved for future extensions
1379 *
1380 * This closes a range of file descriptors. All file descriptors
1381 * from @fd up to and including @max_fd are closed.
1382 * Currently, errors to close a given file descriptor are ignored.
1383 */
SYSCALL_DEFINE3(close_range,unsigned int,fd,unsigned int,max_fd,unsigned int,flags)1384 SYSCALL_DEFINE3(close_range, unsigned int, fd, unsigned int, max_fd,
1385 unsigned int, flags)
1386 {
1387 return __close_range(fd, max_fd, flags);
1388 }
1389
1390 /*
1391 * This routine simulates a hangup on the tty, to arrange that users
1392 * are given clean terminals at login time.
1393 */
SYSCALL_DEFINE0(vhangup)1394 SYSCALL_DEFINE0(vhangup)
1395 {
1396 if (capable(CAP_SYS_TTY_CONFIG)) {
1397 tty_vhangup_self();
1398 return 0;
1399 }
1400 return -EPERM;
1401 }
1402
1403 /*
1404 * Called when an inode is about to be open.
1405 * We use this to disallow opening large files on 32bit systems if
1406 * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1407 * on this flag in sys_open.
1408 */
generic_file_open(struct inode * inode,struct file * filp)1409 int generic_file_open(struct inode * inode, struct file * filp)
1410 {
1411 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1412 return -EOVERFLOW;
1413 return 0;
1414 }
1415
1416 EXPORT_SYMBOL_NS(generic_file_open, ANDROID_GKI_VFS_EXPORT_ONLY);
1417
1418 /*
1419 * This is used by subsystems that don't want seekable
1420 * file descriptors. The function is not supposed to ever fail, the only
1421 * reason it returns an 'int' and not 'void' is so that it can be plugged
1422 * directly into file_operations structure.
1423 */
nonseekable_open(struct inode * inode,struct file * filp)1424 int nonseekable_open(struct inode *inode, struct file *filp)
1425 {
1426 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1427 return 0;
1428 }
1429
1430 EXPORT_SYMBOL(nonseekable_open);
1431
1432 /*
1433 * stream_open is used by subsystems that want stream-like file descriptors.
1434 * Such file descriptors are not seekable and don't have notion of position
1435 * (file.f_pos is always 0 and ppos passed to .read()/.write() is always NULL).
1436 * Contrary to file descriptors of other regular files, .read() and .write()
1437 * can run simultaneously.
1438 *
1439 * stream_open never fails and is marked to return int so that it could be
1440 * directly used as file_operations.open .
1441 */
stream_open(struct inode * inode,struct file * filp)1442 int stream_open(struct inode *inode, struct file *filp)
1443 {
1444 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS);
1445 filp->f_mode |= FMODE_STREAM;
1446 return 0;
1447 }
1448
1449 EXPORT_SYMBOL(stream_open);
1450