]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - fs/open.c
Merge tag 'gvt-fixes-2018-09-10' of https://github.com/intel/gvt-linux into drm-intel...
[mirror_ubuntu-eoan-kernel.git] / fs / open.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/open.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7#include <linux/string.h>
8#include <linux/mm.h>
1da177e4 9#include <linux/file.h>
9f3acc31 10#include <linux/fdtable.h>
0eeca283 11#include <linux/fsnotify.h>
1da177e4 12#include <linux/module.h>
1da177e4
LT
13#include <linux/tty.h>
14#include <linux/namei.h>
15#include <linux/backing-dev.h>
16f7e0fe 16#include <linux/capability.h>
086f7316 17#include <linux/securebits.h>
1da177e4
LT
18#include <linux/security.h>
19#include <linux/mount.h>
5590ff0d 20#include <linux/fcntl.h>
5a0e3ad6 21#include <linux/slab.h>
7c0f6ba6 22#include <linux/uaccess.h>
1da177e4 23#include <linux/fs.h>
ef3daeda 24#include <linux/personality.h>
1da177e4
LT
25#include <linux/pagemap.h>
26#include <linux/syscalls.h>
ab2af1f5 27#include <linux/rcupdate.h>
73241ccc 28#include <linux/audit.h>
97ac7350 29#include <linux/falloc.h>
5ad4e53b 30#include <linux/fs_struct.h>
b65a9cfc 31#include <linux/ima.h>
2dfc1cae 32#include <linux/dnotify.h>
3f6d078d 33#include <linux/compat.h>
1da177e4 34
e81e3f4d
EP
35#include "internal.h"
36
4a30131e
N
37int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
38 struct file *filp)
1da177e4 39{
939a9421 40 int ret;
1da177e4
LT
41 struct iattr newattrs;
42
43 /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
44 if (length < 0)
45 return -EINVAL;
46
47 newattrs.ia_size = length;
4a30131e 48 newattrs.ia_valid = ATTR_SIZE | time_attrs;
cc4e69de
MS
49 if (filp) {
50 newattrs.ia_file = filp;
51 newattrs.ia_valid |= ATTR_FILE;
52 }
1da177e4 53
45f147a1
JK
54 /* Remove suid, sgid, and file capabilities on truncate too */
55 ret = dentry_needs_remove_privs(dentry);
56 if (ret < 0)
57 return ret;
939a9421
AW
58 if (ret)
59 newattrs.ia_valid |= ret | ATTR_FORCE;
7b82dc0e 60
5955102c 61 inode_lock(dentry->d_inode);
27ac0ffe
BF
62 /* Note any delegations or leases have already been broken: */
63 ret = notify_change(dentry, &newattrs, NULL);
5955102c 64 inode_unlock(dentry->d_inode);
939a9421 65 return ret;
1da177e4
LT
66}
67
7df818b2 68long vfs_truncate(const struct path *path, loff_t length)
1da177e4 69{
2d8f3038 70 struct inode *inode;
a02de960 71 long error;
1da177e4 72
a02de960 73 inode = path->dentry->d_inode;
1da177e4
LT
74
75 /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
1da177e4 76 if (S_ISDIR(inode->i_mode))
a02de960 77 return -EISDIR;
1da177e4 78 if (!S_ISREG(inode->i_mode))
a02de960 79 return -EINVAL;
1da177e4 80
a02de960 81 error = mnt_want_write(path->mnt);
1da177e4 82 if (error)
a02de960 83 goto out;
1da177e4 84
256984a8 85 error = inode_permission(inode, MAY_WRITE);
9ac9b847
DH
86 if (error)
87 goto mnt_drop_write_and_out;
1da177e4
LT
88
89 error = -EPERM;
c82e42da 90 if (IS_APPEND(inode))
9ac9b847 91 goto mnt_drop_write_and_out;
1da177e4 92
8cf9ee50 93 error = get_write_access(inode);
1da177e4 94 if (error)
9ac9b847 95 goto mnt_drop_write_and_out;
1da177e4 96
9700382c 97 /*
98 * Make sure that there are no leases. get_write_access() protects
99 * against the truncate racing with a lease-granting setlease().
100 */
8737c930 101 error = break_lease(inode, O_WRONLY);
1da177e4 102 if (error)
9700382c 103 goto put_write_and_out;
1da177e4
LT
104
105 error = locks_verify_truncate(inode, NULL, length);
be6d3e56 106 if (!error)
a02de960 107 error = security_path_truncate(path);
907f4554 108 if (!error)
a02de960 109 error = do_truncate(path->dentry, length, 0, NULL);
1da177e4 110
9700382c 111put_write_and_out:
8cf9ee50 112 put_write_access(inode);
9ac9b847 113mnt_drop_write_and_out:
a02de960 114 mnt_drop_write(path->mnt);
1da177e4
LT
115out:
116 return error;
117}
a02de960
DH
118EXPORT_SYMBOL_GPL(vfs_truncate);
119
df260e21 120long do_sys_truncate(const char __user *pathname, loff_t length)
a02de960 121{
48f7530d 122 unsigned int lookup_flags = LOOKUP_FOLLOW;
a02de960
DH
123 struct path path;
124 int error;
125
126 if (length < 0) /* sorry, but loff_t says... */
127 return -EINVAL;
128
48f7530d
JL
129retry:
130 error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
a02de960
DH
131 if (!error) {
132 error = vfs_truncate(&path, length);
133 path_put(&path);
134 }
48f7530d
JL
135 if (retry_estale(error, lookup_flags)) {
136 lookup_flags |= LOOKUP_REVAL;
137 goto retry;
138 }
a02de960
DH
139 return error;
140}
1da177e4 141
4fd8da8d 142SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
1da177e4 143{
4fd8da8d 144 return do_sys_truncate(path, length);
1da177e4
LT
145}
146
3f6d078d
AV
147#ifdef CONFIG_COMPAT
148COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
149{
150 return do_sys_truncate(path, length);
151}
152#endif
153
411d9475 154long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
1da177e4 155{
bf2965d5 156 struct inode *inode;
1da177e4 157 struct dentry *dentry;
2903ff01 158 struct fd f;
1da177e4
LT
159 int error;
160
161 error = -EINVAL;
162 if (length < 0)
163 goto out;
164 error = -EBADF;
2903ff01
AV
165 f = fdget(fd);
166 if (!f.file)
1da177e4
LT
167 goto out;
168
169 /* explicitly opened as large or we are on 64-bit box */
2903ff01 170 if (f.file->f_flags & O_LARGEFILE)
1da177e4
LT
171 small = 0;
172
2903ff01 173 dentry = f.file->f_path.dentry;
1da177e4
LT
174 inode = dentry->d_inode;
175 error = -EINVAL;
2903ff01 176 if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
1da177e4
LT
177 goto out_putf;
178
179 error = -EINVAL;
180 /* Cannot ftruncate over 2^31 bytes without large file support */
181 if (small && length > MAX_NON_LFS)
182 goto out_putf;
183
184 error = -EPERM;
78757af6
AG
185 /* Check IS_APPEND on real upper inode */
186 if (IS_APPEND(file_inode(f.file)))
1da177e4
LT
187 goto out_putf;
188
14da9200 189 sb_start_write(inode->i_sb);
2903ff01 190 error = locks_verify_truncate(inode, f.file, length);
be6d3e56 191 if (!error)
2903ff01 192 error = security_path_truncate(&f.file->f_path);
1da177e4 193 if (!error)
2903ff01 194 error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
14da9200 195 sb_end_write(inode->i_sb);
1da177e4 196out_putf:
2903ff01 197 fdput(f);
1da177e4
LT
198out:
199 return error;
200}
201
bdc480e3 202SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
1da177e4 203{
2cf09666 204 return do_sys_ftruncate(fd, length, 1);
1da177e4
LT
205}
206
3f6d078d
AV
207#ifdef CONFIG_COMPAT
208COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
209{
210 return do_sys_ftruncate(fd, length, 1);
211}
212#endif
213
1da177e4
LT
214/* LFS versions of truncate are only needed on 32 bit machines */
215#if BITS_PER_LONG == 32
4a0fd5bf 216SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
1da177e4
LT
217{
218 return do_sys_truncate(path, length);
219}
220
4a0fd5bf 221SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
1da177e4 222{
2cf09666 223 return do_sys_ftruncate(fd, length, 0);
1da177e4 224}
6673e0c3 225#endif /* BITS_PER_LONG == 32 */
1da177e4 226
3e63cbb1 227
72c72bdf 228int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
97ac7350 229{
496ad9aa 230 struct inode *inode = file_inode(file);
3e63cbb1 231 long ret;
97ac7350
AA
232
233 if (offset < 0 || len <= 0)
3e63cbb1 234 return -EINVAL;
97ac7350
AA
235
236 /* Return error if mode is not supported */
dd46c787 237 if (mode & ~FALLOC_FL_SUPPORTED_MASK)
409332b6
LC
238 return -EOPNOTSUPP;
239
240 /* Punch hole and zero range are mutually exclusive */
241 if ((mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE)) ==
242 (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE))
79124f18
JB
243 return -EOPNOTSUPP;
244
245 /* Punch hole must have keep size set */
246 if ((mode & FALLOC_FL_PUNCH_HOLE) &&
247 !(mode & FALLOC_FL_KEEP_SIZE))
3e63cbb1 248 return -EOPNOTSUPP;
97ac7350 249
00f5e619
NJ
250 /* Collapse range should only be used exclusively. */
251 if ((mode & FALLOC_FL_COLLAPSE_RANGE) &&
252 (mode & ~FALLOC_FL_COLLAPSE_RANGE))
253 return -EINVAL;
254
dd46c787
NJ
255 /* Insert range should only be used exclusively. */
256 if ((mode & FALLOC_FL_INSERT_RANGE) &&
257 (mode & ~FALLOC_FL_INSERT_RANGE))
258 return -EINVAL;
259
71be6b49
DW
260 /* Unshare range should only be used with allocate mode. */
261 if ((mode & FALLOC_FL_UNSHARE_RANGE) &&
262 (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))
263 return -EINVAL;
264
97ac7350 265 if (!(file->f_mode & FMODE_WRITE))
3e63cbb1 266 return -EBADF;
1ca551c6 267
00f5e619 268 /*
8fc61d92 269 * We can only allow pure fallocate on append only files
00f5e619 270 */
8fc61d92 271 if ((mode & ~FALLOC_FL_KEEP_SIZE) && IS_APPEND(inode))
1ca551c6
MS
272 return -EPERM;
273
274 if (IS_IMMUTABLE(inode))
275 return -EPERM;
276
0790b31b 277 /*
6d2b6170 278 * We cannot allow any fallocate operation on an active swapfile
0790b31b
LC
279 */
280 if (IS_SWAPFILE(inode))
6d2b6170 281 return -ETXTBSY;
0790b31b 282
97ac7350
AA
283 /*
284 * Revalidate the write permissions, in case security policy has
285 * changed since the files were opened.
286 */
287 ret = security_file_permission(file, MAY_WRITE);
288 if (ret)
3e63cbb1 289 return ret;
97ac7350 290
97ac7350 291 if (S_ISFIFO(inode->i_mode))
3e63cbb1 292 return -ESPIPE;
97ac7350 293
9e79b132
AG
294 if (S_ISDIR(inode->i_mode))
295 return -EISDIR;
296
297 if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
3e63cbb1 298 return -ENODEV;
97ac7350 299
97ac7350
AA
300 /* Check for wrap through zero too */
301 if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
3e63cbb1 302 return -EFBIG;
97ac7350 303
2fe17c10 304 if (!file->f_op->fallocate)
3e63cbb1 305 return -EOPNOTSUPP;
97ac7350 306
bfe219d3 307 file_start_write(file);
14da9200 308 ret = file->f_op->fallocate(file, mode, offset, len);
820c12d5
HS
309
310 /*
311 * Create inotify and fanotify events.
312 *
313 * To keep the logic simple always create events if fallocate succeeds.
314 * This implies that events are even created if the file size remains
315 * unchanged, e.g. when using flag FALLOC_FL_KEEP_SIZE.
316 */
317 if (ret == 0)
318 fsnotify_modify(file);
319
bfe219d3 320 file_end_write(file);
14da9200 321 return ret;
3e63cbb1 322}
72c72bdf 323EXPORT_SYMBOL_GPL(vfs_fallocate);
3e63cbb1 324
edf292c7 325int ksys_fallocate(int fd, int mode, loff_t offset, loff_t len)
3e63cbb1 326{
2903ff01 327 struct fd f = fdget(fd);
3e63cbb1
AJ
328 int error = -EBADF;
329
2903ff01 330 if (f.file) {
72c72bdf 331 error = vfs_fallocate(f.file, mode, offset, len);
2903ff01 332 fdput(f);
3e63cbb1 333 }
3e63cbb1 334 return error;
97ac7350 335}
3e63cbb1 336
edf292c7
DB
337SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
338{
339 return ksys_fallocate(fd, mode, offset, len);
340}
341
1da177e4
LT
342/*
343 * access() needs to use the real uid/gid, not the effective uid/gid.
344 * We do this by temporarily clearing all FS-related capabilities and
345 * switching the fsuid/fsgid around to the real ones.
346 */
cbfe20f5 347long do_faccessat(int dfd, const char __user *filename, int mode)
1da177e4 348{
d84f4f99
DH
349 const struct cred *old_cred;
350 struct cred *override_cred;
2d8f3038 351 struct path path;
256984a8 352 struct inode *inode;
1da177e4 353 int res;
87fa5595 354 unsigned int lookup_flags = LOOKUP_FOLLOW;
1da177e4
LT
355
356 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
357 return -EINVAL;
358
d84f4f99
DH
359 override_cred = prepare_creds();
360 if (!override_cred)
361 return -ENOMEM;
1da177e4 362
d84f4f99
DH
363 override_cred->fsuid = override_cred->uid;
364 override_cred->fsgid = override_cred->gid;
1da177e4 365
086f7316 366 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
1cdcbec1 367 /* Clear the capabilities if we switch to a non-root user */
18815a18
EB
368 kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
369 if (!uid_eq(override_cred->uid, root_uid))
d84f4f99 370 cap_clear(override_cred->cap_effective);
086f7316 371 else
d84f4f99
DH
372 override_cred->cap_effective =
373 override_cred->cap_permitted;
086f7316 374 }
1da177e4 375
d84f4f99 376 old_cred = override_creds(override_cred);
87fa5595
JL
377retry:
378 res = user_path_at(dfd, filename, lookup_flags, &path);
6902d925
DH
379 if (res)
380 goto out;
381
63afdfc7 382 inode = d_backing_inode(path.dentry);
256984a8
AV
383
384 if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
30524472
AV
385 /*
386 * MAY_EXEC on regular files is denied if the fs is mounted
387 * with the "noexec" flag.
388 */
389 res = -EACCES;
90f8572b 390 if (path_noexec(&path))
30524472
AV
391 goto out_path_release;
392 }
393
256984a8 394 res = inode_permission(inode, mode | MAY_ACCESS);
6902d925 395 /* SuS v2 requires we report a read only fs too */
256984a8 396 if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
6902d925 397 goto out_path_release;
2f676cbc
DH
398 /*
399 * This is a rare case where using __mnt_is_readonly()
400 * is OK without a mnt_want/drop_write() pair. Since
401 * no actual write to the fs is performed here, we do
402 * not need to telegraph to that to anyone.
403 *
404 * By doing this, we accept that this access is
405 * inherently racy and know that the fs may change
406 * state before we even see this result.
407 */
2d8f3038 408 if (__mnt_is_readonly(path.mnt))
6902d925 409 res = -EROFS;
1da177e4 410
6902d925 411out_path_release:
2d8f3038 412 path_put(&path);
87fa5595
JL
413 if (retry_estale(res, lookup_flags)) {
414 lookup_flags |= LOOKUP_REVAL;
415 goto retry;
416 }
6902d925 417out:
d84f4f99
DH
418 revert_creds(old_cred);
419 put_cred(override_cred);
1da177e4
LT
420 return res;
421}
422
cbfe20f5
DB
423SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
424{
425 return do_faccessat(dfd, filename, mode);
426}
427
ca013e94 428SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
5590ff0d 429{
cbfe20f5 430 return do_faccessat(AT_FDCWD, filename, mode);
5590ff0d
UD
431}
432
447016e9 433int ksys_chdir(const char __user *filename)
1da177e4 434{
2d8f3038 435 struct path path;
1da177e4 436 int error;
0291c0a5
JL
437 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
438retry:
439 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
1da177e4
LT
440 if (error)
441 goto out;
442
9cfcac81 443 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
1da177e4
LT
444 if (error)
445 goto dput_and_out;
446
2d8f3038 447 set_fs_pwd(current->fs, &path);
1da177e4
LT
448
449dput_and_out:
2d8f3038 450 path_put(&path);
0291c0a5
JL
451 if (retry_estale(error, lookup_flags)) {
452 lookup_flags |= LOOKUP_REVAL;
453 goto retry;
454 }
1da177e4
LT
455out:
456 return error;
457}
458
447016e9
DB
459SYSCALL_DEFINE1(chdir, const char __user *, filename)
460{
461 return ksys_chdir(filename);
462}
463
3cdad428 464SYSCALL_DEFINE1(fchdir, unsigned int, fd)
1da177e4 465{
2903ff01 466 struct fd f = fdget_raw(fd);
159b0956 467 int error;
1da177e4
LT
468
469 error = -EBADF;
2903ff01 470 if (!f.file)
1da177e4
LT
471 goto out;
472
1da177e4 473 error = -ENOTDIR;
159b0956 474 if (!d_can_lookup(f.file->f_path.dentry))
1da177e4
LT
475 goto out_putf;
476
159b0956 477 error = inode_permission(file_inode(f.file), MAY_EXEC | MAY_CHDIR);
1da177e4 478 if (!error)
2903ff01 479 set_fs_pwd(current->fs, &f.file->f_path);
1da177e4 480out_putf:
2903ff01 481 fdput(f);
1da177e4
LT
482out:
483 return error;
484}
485
a16fe33a 486int ksys_chroot(const char __user *filename)
1da177e4 487{
2d8f3038 488 struct path path;
1da177e4 489 int error;
2771261e
JL
490 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
491retry:
492 error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
1da177e4
LT
493 if (error)
494 goto out;
495
9cfcac81 496 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
1da177e4
LT
497 if (error)
498 goto dput_and_out;
499
500 error = -EPERM;
c7b96acf 501 if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
1da177e4 502 goto dput_and_out;
8b8efb44
TH
503 error = security_path_chroot(&path);
504 if (error)
505 goto dput_and_out;
1da177e4 506
2d8f3038 507 set_fs_root(current->fs, &path);
1da177e4
LT
508 error = 0;
509dput_and_out:
2d8f3038 510 path_put(&path);
2771261e
JL
511 if (retry_estale(error, lookup_flags)) {
512 lookup_flags |= LOOKUP_REVAL;
513 goto retry;
514 }
1da177e4
LT
515out:
516 return error;
517}
518
a16fe33a
DB
519SYSCALL_DEFINE1(chroot, const char __user *, filename)
520{
521 return ksys_chroot(filename);
522}
523
be01f9f2 524static int chmod_common(const struct path *path, umode_t mode)
1da177e4 525{
e57712eb 526 struct inode *inode = path->dentry->d_inode;
27ac0ffe 527 struct inode *delegated_inode = NULL;
1da177e4 528 struct iattr newattrs;
e57712eb 529 int error;
1da177e4 530
e57712eb
AV
531 error = mnt_want_write(path->mnt);
532 if (error)
533 return error;
27ac0ffe 534retry_deleg:
5955102c 535 inode_lock(inode);
cdcf116d 536 error = security_path_chmod(path, mode);
e57712eb 537 if (error)
fe542cf5 538 goto out_unlock;
1da177e4
LT
539 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
540 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
27ac0ffe 541 error = notify_change(path->dentry, &newattrs, &delegated_inode);
fe542cf5 542out_unlock:
5955102c 543 inode_unlock(inode);
27ac0ffe
BF
544 if (delegated_inode) {
545 error = break_deleg_wait(&delegated_inode);
546 if (!error)
547 goto retry_deleg;
548 }
e57712eb
AV
549 mnt_drop_write(path->mnt);
550 return error;
551}
552
03450e27 553int ksys_fchmod(unsigned int fd, umode_t mode)
e57712eb 554{
173c8401 555 struct fd f = fdget(fd);
e57712eb
AV
556 int err = -EBADF;
557
173c8401 558 if (f.file) {
9f45f5bf 559 audit_file(f.file);
173c8401
AV
560 err = chmod_common(&f.file->f_path, mode);
561 fdput(f);
e57712eb 562 }
1da177e4
LT
563 return err;
564}
565
03450e27
DB
566SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
567{
568 return ksys_fchmod(fd, mode);
569}
570
571int do_fchmodat(int dfd, const char __user *filename, umode_t mode)
1da177e4 572{
2d8f3038 573 struct path path;
1da177e4 574 int error;
14ff690c
JL
575 unsigned int lookup_flags = LOOKUP_FOLLOW;
576retry:
577 error = user_path_at(dfd, filename, lookup_flags, &path);
e57712eb
AV
578 if (!error) {
579 error = chmod_common(&path, mode);
580 path_put(&path);
14ff690c
JL
581 if (retry_estale(error, lookup_flags)) {
582 lookup_flags |= LOOKUP_REVAL;
583 goto retry;
584 }
e57712eb 585 }
1da177e4
LT
586 return error;
587}
588
03450e27
DB
589SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename,
590 umode_t, mode)
591{
592 return do_fchmodat(dfd, filename, mode);
593}
594
49f0a076 595SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
5590ff0d 596{
03450e27 597 return do_fchmodat(AT_FDCWD, filename, mode);
5590ff0d
UD
598}
599
7fd25dac 600static int chown_common(const struct path *path, uid_t user, gid_t group)
1da177e4 601{
fe542cf5 602 struct inode *inode = path->dentry->d_inode;
27ac0ffe 603 struct inode *delegated_inode = NULL;
1da177e4
LT
604 int error;
605 struct iattr newattrs;
52137abe
EB
606 kuid_t uid;
607 kgid_t gid;
608
609 uid = make_kuid(current_user_ns(), user);
610 gid = make_kgid(current_user_ns(), group);
1da177e4 611
c1b8940b 612retry_deleg:
1da177e4
LT
613 newattrs.ia_valid = ATTR_CTIME;
614 if (user != (uid_t) -1) {
52137abe
EB
615 if (!uid_valid(uid))
616 return -EINVAL;
1da177e4 617 newattrs.ia_valid |= ATTR_UID;
52137abe 618 newattrs.ia_uid = uid;
1da177e4
LT
619 }
620 if (group != (gid_t) -1) {
52137abe
EB
621 if (!gid_valid(gid))
622 return -EINVAL;
1da177e4 623 newattrs.ia_valid |= ATTR_GID;
52137abe 624 newattrs.ia_gid = gid;
1da177e4
LT
625 }
626 if (!S_ISDIR(inode->i_mode))
b5376771
SH
627 newattrs.ia_valid |=
628 ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
5955102c 629 inode_lock(inode);
d2b31ca6 630 error = security_path_chown(path, uid, gid);
fe542cf5 631 if (!error)
27ac0ffe 632 error = notify_change(path->dentry, &newattrs, &delegated_inode);
5955102c 633 inode_unlock(inode);
27ac0ffe
BF
634 if (delegated_inode) {
635 error = break_deleg_wait(&delegated_inode);
636 if (!error)
637 goto retry_deleg;
638 }
1da177e4
LT
639 return error;
640}
641
55731b3c
DB
642int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
643 int flag)
5590ff0d 644{
2d8f3038 645 struct path path;
5590ff0d 646 int error = -EINVAL;
65cfc672 647 int lookup_flags;
5590ff0d 648
65cfc672 649 if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
5590ff0d
UD
650 goto out;
651
65cfc672
AV
652 lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
653 if (flag & AT_EMPTY_PATH)
654 lookup_flags |= LOOKUP_EMPTY;
99a5df37 655retry:
65cfc672 656 error = user_path_at(dfd, filename, lookup_flags, &path);
6902d925
DH
657 if (error)
658 goto out;
2d8f3038 659 error = mnt_want_write(path.mnt);
2af482a7
DH
660 if (error)
661 goto out_release;
fe542cf5 662 error = chown_common(&path, user, group);
2d8f3038 663 mnt_drop_write(path.mnt);
2af482a7 664out_release:
2d8f3038 665 path_put(&path);
99a5df37
JL
666 if (retry_estale(error, lookup_flags)) {
667 lookup_flags |= LOOKUP_REVAL;
668 goto retry;
669 }
5590ff0d
UD
670out:
671 return error;
672}
673
55731b3c
DB
674SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
675 gid_t, group, int, flag)
676{
677 return do_fchownat(dfd, filename, user, group, flag);
678}
679
55e4def0 680SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
1da177e4 681{
55731b3c 682 return do_fchownat(AT_FDCWD, filename, user, group, 0);
55e4def0 683}
1da177e4 684
55e4def0
DH
685SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
686{
55731b3c
DB
687 return do_fchownat(AT_FDCWD, filename, user, group,
688 AT_SYMLINK_NOFOLLOW);
1da177e4
LT
689}
690
55731b3c 691int ksys_fchown(unsigned int fd, uid_t user, gid_t group)
1da177e4 692{
2903ff01 693 struct fd f = fdget(fd);
1da177e4
LT
694 int error = -EBADF;
695
2903ff01 696 if (!f.file)
6902d925
DH
697 goto out;
698
6742cee0 699 error = mnt_want_write_file(f.file);
2af482a7
DH
700 if (error)
701 goto out_fput;
9f45f5bf 702 audit_file(f.file);
2903ff01 703 error = chown_common(&f.file->f_path, user, group);
6742cee0 704 mnt_drop_write_file(f.file);
2af482a7 705out_fput:
2903ff01 706 fdput(f);
6902d925 707out:
1da177e4
LT
708 return error;
709}
710
55731b3c
DB
711SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
712{
713 return ksys_fchown(fd, user, group);
714}
715
02e5180d 716static int do_dentry_open(struct file *f,
4bacc9c9 717 struct inode *inode,
ae2bb293 718 int (*open)(struct inode *, struct file *))
1da177e4 719{
1abf0c71 720 static const struct file_operations empty_fops = {};
1da177e4
LT
721 int error;
722
b5bcdda3 723 path_get(&f->f_path);
4bacc9c9 724 f->f_inode = inode;
1da177e4 725 f->f_mapping = inode->i_mapping;
1da177e4 726
5660e13d
JL
727 /* Ensure that we skip any errors that predate opening of the file */
728 f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
729
3f4d5a00 730 if (unlikely(f->f_flags & O_PATH)) {
f5d11409 731 f->f_mode = FMODE_PATH | FMODE_OPENED;
1abf0c71 732 f->f_op = &empty_fops;
af04fadc 733 return 0;
1abf0c71
AV
734 }
735
dd20908a 736 if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
0ccb2863 737 error = get_write_access(inode);
3f4d5a00 738 if (unlikely(error))
1da177e4 739 goto cleanup_file;
0ccb2863 740 error = __mnt_want_write(f->f_path.mnt);
3f4d5a00 741 if (unlikely(error)) {
0ccb2863
AV
742 put_write_access(inode);
743 goto cleanup_file;
744 }
83f936c7 745 f->f_mode |= FMODE_WRITER;
1da177e4
LT
746 }
747
9c225f26 748 /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
63b6df14 749 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
9c225f26
LT
750 f->f_mode |= FMODE_ATOMIC_POS;
751
1abf0c71 752 f->f_op = fops_get(inode->i_fop);
72c2d531
AV
753 if (unlikely(WARN_ON(!f->f_op))) {
754 error = -ENODEV;
755 goto cleanup_all;
756 }
1abf0c71 757
e3f20ae2 758 error = security_file_open(f);
788e7dd4
YN
759 if (error)
760 goto cleanup_all;
761
c568d683 762 error = break_lease(locks_inode(f), f->f_flags);
f3c7691e
BF
763 if (error)
764 goto cleanup_all;
765
ea73ea72
AV
766 /* normally all 3 are set; ->open() can clear them if needed */
767 f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
72c2d531 768 if (!open)
834f2a4a
TM
769 open = f->f_op->open;
770 if (open) {
771 error = open(inode, f);
1da177e4
LT
772 if (error)
773 goto cleanup_all;
774 }
f5d11409 775 f->f_mode |= FMODE_OPENED;
890275b5
MZ
776 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
777 i_readcount_inc(inode);
293bc982 778 if ((f->f_mode & FMODE_READ) &&
84363182 779 likely(f->f_op->read || f->f_op->read_iter))
7f7f25e8 780 f->f_mode |= FMODE_CAN_READ;
293bc982 781 if ((f->f_mode & FMODE_WRITE) &&
84363182 782 likely(f->f_op->write || f->f_op->write_iter))
7f7f25e8 783 f->f_mode |= FMODE_CAN_WRITE;
834f2a4a 784
c75b1d94 785 f->f_write_hint = WRITE_LIFE_NOT_SET;
1da177e4
LT
786 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
787
788 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
af04fadc 789
69527c55
AV
790 /* NB: we're sure to have correct a_ops only after f_op->open */
791 if (f->f_flags & O_DIRECT) {
792 if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO)
793 return -EINVAL;
794 }
96b7e579 795 return 0;
1da177e4
LT
796
797cleanup_all:
6b4e8085
AV
798 if (WARN_ON_ONCE(error > 0))
799 error = -EINVAL;
1da177e4 800 fops_put(f->f_op);
83f936c7 801 if (f->f_mode & FMODE_WRITER) {
1da177e4 802 put_write_access(inode);
83f936c7 803 __mnt_drop_write(f->f_path.mnt);
4a3fd211 804 }
1da177e4 805cleanup_file:
02e5180d
AV
806 path_put(&f->f_path);
807 f->f_path.mnt = NULL;
808 f->f_path.dentry = NULL;
dd37978c 809 f->f_inode = NULL;
96b7e579 810 return error;
1da177e4
LT
811}
812
d18e9008
MS
813/**
814 * finish_open - finish opening a file
0854d450 815 * @file: file pointer
d18e9008
MS
816 * @dentry: pointer to dentry
817 * @open: open callback
0854d450 818 * @opened: state of open
d18e9008
MS
819 *
820 * This can be used to finish opening a file passed to i_op->atomic_open().
821 *
822 * If the open callback is set to NULL, then the standard f_op->open()
823 * filesystem callback is substituted.
0854d450
MS
824 *
825 * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
826 * the return value of d_splice_alias(), then the caller needs to perform dput()
827 * on it after finish_open().
828 *
829 * On successful return @file is a fully instantiated open file. After this, if
830 * an error occurs in ->atomic_open(), it needs to clean up with fput().
831 *
832 * Returns zero on success or -errno if the open failed.
d18e9008 833 */
30d90494 834int finish_open(struct file *file, struct dentry *dentry,
be12af3e 835 int (*open)(struct inode *, struct file *))
d18e9008 836{
aad888f8 837 BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */
d18e9008 838
b5bcdda3 839 file->f_path.dentry = dentry;
aad888f8 840 return do_dentry_open(file, d_backing_inode(dentry), open);
d18e9008
MS
841}
842EXPORT_SYMBOL(finish_open);
843
844/**
845 * finish_no_open - finish ->atomic_open() without opening the file
846 *
0854d450 847 * @file: file pointer
d18e9008
MS
848 * @dentry: dentry or NULL (as returned from ->lookup())
849 *
850 * This can be used to set the result of a successful lookup in ->atomic_open().
0854d450
MS
851 *
852 * NB: unlike finish_open() this function does consume the dentry reference and
853 * the caller need not dput() it.
854 *
64e1ac4d 855 * Returns "0" which must be the return value of ->atomic_open() after having
0854d450 856 * called this function.
d18e9008 857 */
e45198a6 858int finish_no_open(struct file *file, struct dentry *dentry)
d18e9008 859{
30d90494 860 file->f_path.dentry = dentry;
64e1ac4d 861 return 0;
d18e9008
MS
862}
863EXPORT_SYMBOL(finish_no_open);
864
9bf39ab2
MS
865char *file_path(struct file *filp, char *buf, int buflen)
866{
867 return d_path(&filp->f_path, buf, buflen);
868}
869EXPORT_SYMBOL(file_path);
870
4bacc9c9
DH
871/**
872 * vfs_open - open the file at the given path
873 * @path: path to open
874 * @file: newly allocated file with f_flag initialized
875 * @cred: credentials to use
876 */
ae2bb293 877int vfs_open(const struct path *path, struct file *file)
4bacc9c9 878{
54d5ca87 879 file->f_path = *path;
a6518f73 880 return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
4bacc9c9
DH
881}
882
765927b2 883struct file *dentry_open(const struct path *path, int flags,
745ca247 884 const struct cred *cred)
a1a5b3d9
PS
885{
886 int error;
887 struct file *f;
888
e0e81739
DH
889 validate_creds(cred);
890
c212f9aa 891 /* We must always pass in a valid mount pointer. */
765927b2 892 BUG_ON(!path->mnt);
322ee5b3 893
ea73ea72 894 f = alloc_empty_file(flags, cred);
af04fadc 895 if (!IS_ERR(f)) {
ae2bb293 896 error = vfs_open(path, f);
4d27f326
AV
897 if (error) {
898 fput(f);
af04fadc
AV
899 f = ERR_PTR(error);
900 }
2a027e7a
AV
901 }
902 return f;
a1a5b3d9 903}
1da177e4
LT
904EXPORT_SYMBOL(dentry_open);
905
2abc77af
AV
906struct file *open_with_fake_path(const struct path *path, int flags,
907 struct inode *inode, const struct cred *cred)
908{
d3b1084d 909 struct file *f = alloc_empty_file_noaccount(flags, cred);
2abc77af
AV
910 if (!IS_ERR(f)) {
911 int error;
912
913 f->f_path = *path;
914 error = do_dentry_open(f, inode, NULL);
915 if (error) {
916 fput(f);
917 f = ERR_PTR(error);
918 }
919 }
920 return f;
921}
922EXPORT_SYMBOL(open_with_fake_path);
923
a218d0fd 924static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
47c805dc
AV
925{
926 int lookup_flags = 0;
62fb4a15 927 int acc_mode = ACC_MODE(flags);
47c805dc 928
629e014b
CH
929 /*
930 * Clear out all open flags we don't know about so that we don't report
931 * them in fcntl(F_GETFD) or similar interfaces.
932 */
933 flags &= VALID_OPEN_FLAGS;
934
e305f48b 935 if (flags & (O_CREAT | __O_TMPFILE))
e68726ff
MS
936 op->mode = (mode & S_IALLUGO) | S_IFREG;
937 else
938 op->mode = 0;
47c805dc
AV
939
940 /* Must never be set by userspace */
c6f3d811 941 flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
47c805dc
AV
942
943 /*
944 * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
945 * check for O_DSYNC if the need any syncing at all we enforce it's
946 * always set instead of having to deal with possibly weird behaviour
947 * for malicious applications setting only __O_SYNC.
948 */
949 if (flags & __O_SYNC)
950 flags |= O_DSYNC;
951
bb458c64
AV
952 if (flags & __O_TMPFILE) {
953 if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
60545d0d 954 return -EINVAL;
ba57ea64
AV
955 if (!(acc_mode & MAY_WRITE))
956 return -EINVAL;
60545d0d
AV
957 } else if (flags & O_PATH) {
958 /*
959 * If we have O_PATH in the open flag. Then we
960 * cannot have anything other than the below set of flags
961 */
1abf0c71
AV
962 flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
963 acc_mode = 0;
1abf0c71 964 }
47c805dc 965
1abf0c71 966 op->open_flag = flags;
47c805dc
AV
967
968 /* O_TRUNC implies we need access checks for write permissions */
969 if (flags & O_TRUNC)
970 acc_mode |= MAY_WRITE;
971
972 /* Allow the LSM permission hook to distinguish append
973 access from general write access. */
974 if (flags & O_APPEND)
975 acc_mode |= MAY_APPEND;
976
977 op->acc_mode = acc_mode;
978
1abf0c71
AV
979 op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
980
47c805dc
AV
981 if (flags & O_CREAT) {
982 op->intent |= LOOKUP_CREATE;
983 if (flags & O_EXCL)
984 op->intent |= LOOKUP_EXCL;
985 }
986
987 if (flags & O_DIRECTORY)
988 lookup_flags |= LOOKUP_DIRECTORY;
989 if (!(flags & O_NOFOLLOW))
990 lookup_flags |= LOOKUP_FOLLOW;
f9652e10
AV
991 op->lookup_flags = lookup_flags;
992 return 0;
47c805dc
AV
993}
994
669abf4e
JL
995/**
996 * file_open_name - open file and return file pointer
997 *
998 * @name: struct filename containing path to open
999 * @flags: open flags as per the open(2) second argument
1000 * @mode: mode for the new file if O_CREAT is set, else ignored
1001 *
1002 * This is the helper to open a file from kernelspace if you really
1003 * have to. But in generally you should not do this, so please move
1004 * along, nothing to see here..
1005 */
1006struct file *file_open_name(struct filename *name, int flags, umode_t mode)
1007{
1008 struct open_flags op;
f9652e10
AV
1009 int err = build_open_flags(flags, mode, &op);
1010 return err ? ERR_PTR(err) : do_filp_open(AT_FDCWD, name, &op);
669abf4e
JL
1011}
1012
47c805dc
AV
1013/**
1014 * filp_open - open file and return file pointer
1015 *
1016 * @filename: path to open
1017 * @flags: open flags as per the open(2) second argument
1018 * @mode: mode for the new file if O_CREAT is set, else ignored
1019 *
1020 * This is the helper to open a file from kernelspace if you really
1021 * have to. But in generally you should not do this, so please move
1022 * along, nothing to see here..
1023 */
a218d0fd 1024struct file *filp_open(const char *filename, int flags, umode_t mode)
47c805dc 1025{
51689104
PM
1026 struct filename *name = getname_kernel(filename);
1027 struct file *file = ERR_CAST(name);
1028
1029 if (!IS_ERR(name)) {
1030 file = file_open_name(name, flags, mode);
1031 putname(name);
1032 }
1033 return file;
47c805dc
AV
1034}
1035EXPORT_SYMBOL(filp_open);
1036
73d049a4 1037struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
378c6520 1038 const char *filename, int flags, umode_t mode)
73d049a4
AV
1039{
1040 struct open_flags op;
378c6520 1041 int err = build_open_flags(flags, mode, &op);
f9652e10
AV
1042 if (err)
1043 return ERR_PTR(err);
f9652e10 1044 return do_file_open_root(dentry, mnt, filename, &op);
73d049a4
AV
1045}
1046EXPORT_SYMBOL(file_open_root);
1047
a218d0fd 1048long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
1da177e4 1049{
47c805dc 1050 struct open_flags op;
f9652e10
AV
1051 int fd = build_open_flags(flags, mode, &op);
1052 struct filename *tmp;
1053
1054 if (fd)
1055 return fd;
1056
1057 tmp = getname(filename);
1058 if (IS_ERR(tmp))
1059 return PTR_ERR(tmp);
1060
1061 fd = get_unused_fd_flags(flags);
1062 if (fd >= 0) {
1063 struct file *f = do_filp_open(dfd, tmp, &op);
1064 if (IS_ERR(f)) {
1065 put_unused_fd(fd);
1066 fd = PTR_ERR(f);
1067 } else {
1068 fsnotify_open(f);
1069 fd_install(fd, f);
1da177e4 1070 }
1da177e4 1071 }
f9652e10 1072 putname(tmp);
1da177e4 1073 return fd;
1da177e4 1074}
e922efc3 1075
a218d0fd 1076SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
e922efc3
MS
1077{
1078 if (force_o_largefile())
1079 flags |= O_LARGEFILE;
1080
2cf09666 1081 return do_sys_open(AT_FDCWD, filename, flags, mode);
e922efc3 1082}
1da177e4 1083
6559eed8 1084SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
a218d0fd 1085 umode_t, mode)
5590ff0d
UD
1086{
1087 if (force_o_largefile())
1088 flags |= O_LARGEFILE;
1089
2cf09666 1090 return do_sys_open(dfd, filename, flags, mode);
5590ff0d 1091}
5590ff0d 1092
e35d49f6
AV
1093#ifdef CONFIG_COMPAT
1094/*
1095 * Exactly like sys_open(), except that it doesn't set the
1096 * O_LARGEFILE flag.
1097 */
1098COMPAT_SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1099{
1100 return do_sys_open(AT_FDCWD, filename, flags, mode);
1101}
1102
1103/*
1104 * Exactly like sys_openat(), except that it doesn't set the
1105 * O_LARGEFILE flag.
1106 */
1107COMPAT_SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags, umode_t, mode)
1108{
1109 return do_sys_open(dfd, filename, flags, mode);
1110}
1111#endif
1112
1da177e4
LT
1113#ifndef __alpha__
1114
1115/*
1116 * For backward compatibility? Maybe this should be moved
1117 * into arch/i386 instead?
1118 */
a218d0fd 1119SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1da177e4 1120{
bae217ea 1121 return ksys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1da177e4
LT
1122}
1123
1124#endif
1125
1126/*
1127 * "id" is the POSIX thread ID. We use the
1128 * files pointer for this..
1129 */
1130int filp_close(struct file *filp, fl_owner_t id)
1131{
45778ca8 1132 int retval = 0;
1da177e4
LT
1133
1134 if (!file_count(filp)) {
1135 printk(KERN_ERR "VFS: Close: file count is 0\n");
45778ca8 1136 return 0;
1da177e4
LT
1137 }
1138
72c2d531 1139 if (filp->f_op->flush)
75e1fcc0 1140 retval = filp->f_op->flush(filp, id);
1da177e4 1141
1abf0c71
AV
1142 if (likely(!(filp->f_mode & FMODE_PATH))) {
1143 dnotify_flush(filp, id);
1144 locks_remove_posix(filp, id);
1145 }
1da177e4
LT
1146 fput(filp);
1147 return retval;
1148}
1149
1150EXPORT_SYMBOL(filp_close);
1151
1152/*
1153 * Careful here! We test whether the file pointer is NULL before
1154 * releasing the fd. This ensures that one clone task can't release
1155 * an fd while another clone is opening it.
1156 */
ca013e94 1157SYSCALL_DEFINE1(close, unsigned int, fd)
1da177e4 1158{
483ce1d4 1159 int retval = __close_fd(current->files, fd);
ee731f4f
EP
1160
1161 /* can't restart close syscall because file table entry was cleared */
1162 if (unlikely(retval == -ERESTARTSYS ||
1163 retval == -ERESTARTNOINTR ||
1164 retval == -ERESTARTNOHAND ||
1165 retval == -ERESTART_RESTARTBLOCK))
1166 retval = -EINTR;
1167
1168 return retval;
1da177e4 1169}
1da177e4
LT
1170
1171/*
1172 * This routine simulates a hangup on the tty, to arrange that users
1173 * are given clean terminals at login time.
1174 */
ca013e94 1175SYSCALL_DEFINE0(vhangup)
1da177e4
LT
1176{
1177 if (capable(CAP_SYS_TTY_CONFIG)) {
2cb5998b 1178 tty_vhangup_self();
1da177e4
LT
1179 return 0;
1180 }
1181 return -EPERM;
1182}
1183
1184/*
1185 * Called when an inode is about to be open.
1186 * We use this to disallow opening large files on 32bit systems if
1187 * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1188 * on this flag in sys_open.
1189 */
1190int generic_file_open(struct inode * inode, struct file * filp)
1191{
1192 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
a9c62a18 1193 return -EOVERFLOW;
1da177e4
LT
1194 return 0;
1195}
1196
1197EXPORT_SYMBOL(generic_file_open);
1198
1199/*
1200 * This is used by subsystems that don't want seekable
06b1e104
DT
1201 * file descriptors. The function is not supposed to ever fail, the only
1202 * reason it returns an 'int' and not 'void' is so that it can be plugged
1203 * directly into file_operations structure.
1da177e4
LT
1204 */
1205int nonseekable_open(struct inode *inode, struct file *filp)
1206{
1207 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1208 return 0;
1209}
1210
1211EXPORT_SYMBOL(nonseekable_open);