Branch data Line data Source code
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 : :
36 : : #include "internal.h"
37 : :
38 : 3 : int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
39 : : struct file *filp)
40 : : {
41 : : int ret;
42 : : struct iattr newattrs;
43 : :
44 : : /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
45 : 3 : if (length < 0)
46 : : return -EINVAL;
47 : :
48 : 3 : newattrs.ia_size = length;
49 : 3 : newattrs.ia_valid = ATTR_SIZE | time_attrs;
50 : 3 : if (filp) {
51 : 3 : newattrs.ia_file = filp;
52 : 3 : newattrs.ia_valid |= ATTR_FILE;
53 : : }
54 : :
55 : : /* Remove suid, sgid, and file capabilities on truncate too */
56 : 3 : ret = dentry_needs_remove_privs(dentry);
57 : 3 : if (ret < 0)
58 : : return ret;
59 : 3 : if (ret)
60 : 0 : newattrs.ia_valid |= ret | ATTR_FORCE;
61 : :
62 : 3 : inode_lock(dentry->d_inode);
63 : : /* Note any delegations or leases have already been broken: */
64 : 3 : ret = notify_change(dentry, &newattrs, NULL);
65 : 3 : inode_unlock(dentry->d_inode);
66 : 3 : return ret;
67 : : }
68 : :
69 : 0 : long vfs_truncate(const struct path *path, loff_t length)
70 : : {
71 : : struct inode *inode;
72 : : long error;
73 : :
74 : 0 : inode = path->dentry->d_inode;
75 : :
76 : : /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
77 : 0 : if (S_ISDIR(inode->i_mode))
78 : : return -EISDIR;
79 : 0 : if (!S_ISREG(inode->i_mode))
80 : : return -EINVAL;
81 : :
82 : 0 : error = mnt_want_write(path->mnt);
83 : 0 : if (error)
84 : : goto out;
85 : :
86 : 0 : error = inode_permission(inode, MAY_WRITE);
87 : 0 : if (error)
88 : : goto mnt_drop_write_and_out;
89 : :
90 : : error = -EPERM;
91 : 0 : if (IS_APPEND(inode))
92 : : goto mnt_drop_write_and_out;
93 : :
94 : : error = get_write_access(inode);
95 : 0 : if (error)
96 : : goto mnt_drop_write_and_out;
97 : :
98 : : /*
99 : : * Make sure that there are no leases. get_write_access() protects
100 : : * against the truncate racing with a lease-granting setlease().
101 : : */
102 : 0 : error = break_lease(inode, O_WRONLY);
103 : 0 : if (error)
104 : : goto put_write_and_out;
105 : :
106 : 0 : error = locks_verify_truncate(inode, NULL, length);
107 : 0 : if (!error)
108 : 0 : error = security_path_truncate(path);
109 : 0 : if (!error)
110 : 0 : error = do_truncate(path->dentry, length, 0, NULL);
111 : :
112 : : put_write_and_out:
113 : : put_write_access(inode);
114 : : mnt_drop_write_and_out:
115 : 0 : mnt_drop_write(path->mnt);
116 : : out:
117 : 0 : return error;
118 : : }
119 : : EXPORT_SYMBOL_GPL(vfs_truncate);
120 : :
121 : 0 : long do_sys_truncate(const char __user *pathname, loff_t length)
122 : : {
123 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
124 : : struct path path;
125 : : int error;
126 : :
127 : 0 : if (length < 0) /* sorry, but loff_t says... */
128 : : return -EINVAL;
129 : :
130 : : retry:
131 : : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
132 : 0 : if (!error) {
133 : 0 : error = vfs_truncate(&path, length);
134 : 0 : path_put(&path);
135 : : }
136 : 0 : if (retry_estale(error, lookup_flags)) {
137 : : lookup_flags |= LOOKUP_REVAL;
138 : : goto retry;
139 : : }
140 : 0 : return error;
141 : : }
142 : :
143 : 0 : SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
144 : : {
145 : 0 : return do_sys_truncate(path, length);
146 : : }
147 : :
148 : : #ifdef CONFIG_COMPAT
149 : : COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
150 : : {
151 : : return do_sys_truncate(path, length);
152 : : }
153 : : #endif
154 : :
155 : 3 : long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
156 : : {
157 : : struct inode *inode;
158 : : struct dentry *dentry;
159 : : struct fd f;
160 : : int error;
161 : :
162 : : error = -EINVAL;
163 : 3 : if (length < 0)
164 : : goto out;
165 : : error = -EBADF;
166 : : f = fdget(fd);
167 : 3 : if (!f.file)
168 : : goto out;
169 : :
170 : : /* explicitly opened as large or we are on 64-bit box */
171 : 3 : if (f.file->f_flags & O_LARGEFILE)
172 : : small = 0;
173 : :
174 : 3 : dentry = f.file->f_path.dentry;
175 : 3 : inode = dentry->d_inode;
176 : : error = -EINVAL;
177 : 3 : if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
178 : : goto out_putf;
179 : :
180 : : error = -EINVAL;
181 : : /* Cannot ftruncate over 2^31 bytes without large file support */
182 : 3 : if (small && length > MAX_NON_LFS)
183 : : goto out_putf;
184 : :
185 : : error = -EPERM;
186 : : /* Check IS_APPEND on real upper inode */
187 : 3 : if (IS_APPEND(file_inode(f.file)))
188 : : goto out_putf;
189 : :
190 : 3 : sb_start_write(inode->i_sb);
191 : 3 : error = locks_verify_truncate(inode, f.file, length);
192 : 3 : if (!error)
193 : 3 : error = security_path_truncate(&f.file->f_path);
194 : 3 : if (!error)
195 : 3 : error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
196 : 3 : sb_end_write(inode->i_sb);
197 : : out_putf:
198 : : fdput(f);
199 : : out:
200 : 3 : return error;
201 : : }
202 : :
203 : 3 : SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
204 : : {
205 : 3 : return do_sys_ftruncate(fd, length, 1);
206 : : }
207 : :
208 : : #ifdef CONFIG_COMPAT
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
217 : 0 : SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
218 : : {
219 : 0 : return do_sys_truncate(path, length);
220 : : }
221 : :
222 : 3 : SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
223 : : {
224 : 3 : return do_sys_ftruncate(fd, length, 0);
225 : : }
226 : : #endif /* BITS_PER_LONG == 32 */
227 : :
228 : :
229 : 3 : 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 : 3 : if (offset < 0 || len <= 0)
235 : : return -EINVAL;
236 : :
237 : : /* Return error if mode is not supported */
238 : 3 : if (mode & ~FALLOC_FL_SUPPORTED_MASK)
239 : : return -EOPNOTSUPP;
240 : :
241 : : /* Punch hole and zero range are mutually exclusive */
242 : 3 : 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 : 3 : 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 : 3 : if ((mode & FALLOC_FL_COLLAPSE_RANGE) &&
253 : 0 : (mode & ~FALLOC_FL_COLLAPSE_RANGE))
254 : : return -EINVAL;
255 : :
256 : : /* Insert range should only be used exclusively. */
257 : 3 : if ((mode & FALLOC_FL_INSERT_RANGE) &&
258 : 0 : (mode & ~FALLOC_FL_INSERT_RANGE))
259 : : return -EINVAL;
260 : :
261 : : /* Unshare range should only be used with allocate mode. */
262 : 3 : if ((mode & FALLOC_FL_UNSHARE_RANGE) &&
263 : 0 : (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))
264 : : return -EINVAL;
265 : :
266 : 3 : if (!(file->f_mode & FMODE_WRITE))
267 : : return -EBADF;
268 : :
269 : : /*
270 : : * We can only allow pure fallocate on append only files
271 : : */
272 : 3 : if ((mode & ~FALLOC_FL_KEEP_SIZE) && IS_APPEND(inode))
273 : : return -EPERM;
274 : :
275 : 3 : if (IS_IMMUTABLE(inode))
276 : : return -EPERM;
277 : :
278 : : /*
279 : : * We cannot allow any fallocate operation on an active swapfile
280 : : */
281 : 3 : 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 : 3 : ret = security_file_permission(file, MAY_WRITE);
289 : 3 : if (ret)
290 : : return ret;
291 : :
292 : 3 : if (S_ISFIFO(inode->i_mode))
293 : : return -ESPIPE;
294 : :
295 : 3 : if (S_ISDIR(inode->i_mode))
296 : : return -EISDIR;
297 : :
298 : 3 : if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
299 : : return -ENODEV;
300 : :
301 : : /* Check for wrap through zero too */
302 : 3 : if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
303 : : return -EFBIG;
304 : :
305 : 3 : if (!file->f_op->fallocate)
306 : : return -EOPNOTSUPP;
307 : :
308 : 3 : file_start_write(file);
309 : 3 : 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 : 3 : if (ret == 0)
319 : 3 : fsnotify_modify(file);
320 : :
321 : 3 : file_end_write(file);
322 : 3 : return ret;
323 : : }
324 : : EXPORT_SYMBOL_GPL(vfs_fallocate);
325 : :
326 : 3 : int ksys_fallocate(int fd, int mode, loff_t offset, loff_t len)
327 : : {
328 : 3 : struct fd f = fdget(fd);
329 : : int error = -EBADF;
330 : :
331 : 3 : if (f.file) {
332 : 3 : error = vfs_fallocate(f.file, mode, offset, len);
333 : : fdput(f);
334 : : }
335 : 3 : return error;
336 : : }
337 : :
338 : 3 : SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
339 : : {
340 : 3 : 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 : : */
348 : 3 : long do_faccessat(int dfd, const char __user *filename, int mode)
349 : : {
350 : : const struct cred *old_cred;
351 : : struct cred *override_cred;
352 : : struct path path;
353 : : struct inode *inode;
354 : : int res;
355 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
356 : :
357 : 3 : if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
358 : : return -EINVAL;
359 : :
360 : 3 : override_cred = prepare_creds();
361 : 3 : if (!override_cred)
362 : : return -ENOMEM;
363 : :
364 : 3 : override_cred->fsuid = override_cred->uid;
365 : 3 : override_cred->fsgid = override_cred->gid;
366 : :
367 : 3 : if (!issecure(SECURE_NO_SETUID_FIXUP)) {
368 : : /* Clear the capabilities if we switch to a non-root user */
369 : 3 : kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
370 : 3 : if (!uid_eq(override_cred->uid, root_uid))
371 : 3 : cap_clear(override_cred->cap_effective);
372 : : else
373 : 3 : override_cred->cap_effective =
374 : : override_cred->cap_permitted;
375 : : }
376 : :
377 : : /*
378 : : * The new set of credentials can *only* be used in
379 : : * task-synchronous circumstances, and does not need
380 : : * RCU freeing, unless somebody then takes a separate
381 : : * reference to it.
382 : : *
383 : : * NOTE! This is _only_ true because this credential
384 : : * is used purely for override_creds() that installs
385 : : * it as the subjective cred. Other threads will be
386 : : * accessing ->real_cred, not the subjective cred.
387 : : *
388 : : * If somebody _does_ make a copy of this (using the
389 : : * 'get_current_cred()' function), that will clear the
390 : : * non_rcu field, because now that other user may be
391 : : * expecting RCU freeing. But normal thread-synchronous
392 : : * cred accesses will keep things non-RCY.
393 : : */
394 : 3 : override_cred->non_rcu = 1;
395 : :
396 : 3 : old_cred = override_creds(override_cred);
397 : : retry:
398 : : res = user_path_at(dfd, filename, lookup_flags, &path);
399 : 3 : if (res)
400 : : goto out;
401 : :
402 : 3 : inode = d_backing_inode(path.dentry);
403 : :
404 : 3 : if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
405 : : /*
406 : : * MAY_EXEC on regular files is denied if the fs is mounted
407 : : * with the "noexec" flag.
408 : : */
409 : : res = -EACCES;
410 : 3 : if (path_noexec(&path))
411 : : goto out_path_release;
412 : : }
413 : :
414 : 3 : res = inode_permission(inode, mode | MAY_ACCESS);
415 : : /* SuS v2 requires we report a read only fs too */
416 : 3 : if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
417 : : goto out_path_release;
418 : : /*
419 : : * This is a rare case where using __mnt_is_readonly()
420 : : * is OK without a mnt_want/drop_write() pair. Since
421 : : * no actual write to the fs is performed here, we do
422 : : * not need to telegraph to that to anyone.
423 : : *
424 : : * By doing this, we accept that this access is
425 : : * inherently racy and know that the fs may change
426 : : * state before we even see this result.
427 : : */
428 : 3 : if (__mnt_is_readonly(path.mnt))
429 : : res = -EROFS;
430 : :
431 : : out_path_release:
432 : 3 : path_put(&path);
433 : 3 : if (retry_estale(res, lookup_flags)) {
434 : : lookup_flags |= LOOKUP_REVAL;
435 : : goto retry;
436 : : }
437 : : out:
438 : 3 : revert_creds(old_cred);
439 : 3 : put_cred(override_cred);
440 : 3 : return res;
441 : : }
442 : :
443 : 3 : SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
444 : : {
445 : 3 : return do_faccessat(dfd, filename, mode);
446 : : }
447 : :
448 : 3 : SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
449 : : {
450 : 3 : return do_faccessat(AT_FDCWD, filename, mode);
451 : : }
452 : :
453 : 3 : int ksys_chdir(const char __user *filename)
454 : : {
455 : : struct path path;
456 : : int error;
457 : : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
458 : : retry:
459 : : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
460 : 3 : if (error)
461 : : goto out;
462 : :
463 : 3 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
464 : 3 : if (error)
465 : : goto dput_and_out;
466 : :
467 : 3 : set_fs_pwd(current->fs, &path);
468 : :
469 : : dput_and_out:
470 : 3 : path_put(&path);
471 : 3 : if (retry_estale(error, lookup_flags)) {
472 : : lookup_flags |= LOOKUP_REVAL;
473 : : goto retry;
474 : : }
475 : : out:
476 : 3 : return error;
477 : : }
478 : :
479 : 3 : SYSCALL_DEFINE1(chdir, const char __user *, filename)
480 : : {
481 : 3 : return ksys_chdir(filename);
482 : : }
483 : :
484 : 3 : SYSCALL_DEFINE1(fchdir, unsigned int, fd)
485 : : {
486 : : struct fd f = fdget_raw(fd);
487 : : int error;
488 : :
489 : : error = -EBADF;
490 : 3 : if (!f.file)
491 : : goto out;
492 : :
493 : : error = -ENOTDIR;
494 : 3 : if (!d_can_lookup(f.file->f_path.dentry))
495 : : goto out_putf;
496 : :
497 : 3 : error = inode_permission(file_inode(f.file), MAY_EXEC | MAY_CHDIR);
498 : 3 : if (!error)
499 : 3 : set_fs_pwd(current->fs, &f.file->f_path);
500 : : out_putf:
501 : : fdput(f);
502 : : out:
503 : 3 : return error;
504 : : }
505 : :
506 : 3 : int ksys_chroot(const char __user *filename)
507 : : {
508 : : struct path path;
509 : : int error;
510 : : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
511 : : retry:
512 : : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
513 : 3 : if (error)
514 : : goto out;
515 : :
516 : 3 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
517 : 3 : if (error)
518 : : goto dput_and_out;
519 : :
520 : : error = -EPERM;
521 : 3 : if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
522 : : goto dput_and_out;
523 : 3 : error = security_path_chroot(&path);
524 : 3 : if (error)
525 : : goto dput_and_out;
526 : :
527 : 3 : set_fs_root(current->fs, &path);
528 : : error = 0;
529 : : dput_and_out:
530 : 3 : path_put(&path);
531 : 3 : if (retry_estale(error, lookup_flags)) {
532 : : lookup_flags |= LOOKUP_REVAL;
533 : : goto retry;
534 : : }
535 : : out:
536 : 3 : return error;
537 : : }
538 : :
539 : 3 : SYSCALL_DEFINE1(chroot, const char __user *, filename)
540 : : {
541 : 3 : return ksys_chroot(filename);
542 : : }
543 : :
544 : 3 : static int chmod_common(const struct path *path, umode_t mode)
545 : : {
546 : 3 : struct inode *inode = path->dentry->d_inode;
547 : 3 : struct inode *delegated_inode = NULL;
548 : : struct iattr newattrs;
549 : : int error;
550 : :
551 : 3 : error = mnt_want_write(path->mnt);
552 : 3 : if (error)
553 : : return error;
554 : : retry_deleg:
555 : : inode_lock(inode);
556 : 3 : error = security_path_chmod(path, mode);
557 : 3 : if (error)
558 : : goto out_unlock;
559 : 3 : newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
560 : 3 : newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
561 : 3 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
562 : : out_unlock:
563 : : inode_unlock(inode);
564 : 3 : if (delegated_inode) {
565 : 0 : error = break_deleg_wait(&delegated_inode);
566 : 0 : if (!error)
567 : : goto retry_deleg;
568 : : }
569 : 3 : mnt_drop_write(path->mnt);
570 : 3 : return error;
571 : : }
572 : :
573 : 3 : int ksys_fchmod(unsigned int fd, umode_t mode)
574 : : {
575 : : struct fd f = fdget(fd);
576 : : int err = -EBADF;
577 : :
578 : 3 : if (f.file) {
579 : 3 : audit_file(f.file);
580 : 3 : err = chmod_common(&f.file->f_path, mode);
581 : : fdput(f);
582 : : }
583 : 3 : return err;
584 : : }
585 : :
586 : 3 : SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
587 : : {
588 : 3 : return ksys_fchmod(fd, mode);
589 : : }
590 : :
591 : 3 : int do_fchmodat(int dfd, const char __user *filename, umode_t mode)
592 : : {
593 : : struct path path;
594 : : int error;
595 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
596 : : retry:
597 : : error = user_path_at(dfd, filename, lookup_flags, &path);
598 : 3 : if (!error) {
599 : 3 : error = chmod_common(&path, mode);
600 : 3 : path_put(&path);
601 : 3 : if (retry_estale(error, lookup_flags)) {
602 : : lookup_flags |= LOOKUP_REVAL;
603 : : goto retry;
604 : : }
605 : : }
606 : 3 : return error;
607 : : }
608 : :
609 : 3 : SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename,
610 : : umode_t, mode)
611 : : {
612 : 3 : return do_fchmodat(dfd, filename, mode);
613 : : }
614 : :
615 : 3 : SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
616 : : {
617 : 3 : return do_fchmodat(AT_FDCWD, filename, mode);
618 : : }
619 : :
620 : 3 : static int chown_common(const struct path *path, uid_t user, gid_t group)
621 : : {
622 : 3 : struct inode *inode = path->dentry->d_inode;
623 : 3 : struct inode *delegated_inode = NULL;
624 : : int error;
625 : : struct iattr newattrs;
626 : : kuid_t uid;
627 : : kgid_t gid;
628 : :
629 : 3 : uid = make_kuid(current_user_ns(), user);
630 : 3 : gid = make_kgid(current_user_ns(), group);
631 : :
632 : : retry_deleg:
633 : 3 : newattrs.ia_valid = ATTR_CTIME;
634 : 3 : if (user != (uid_t) -1) {
635 : 3 : if (!uid_valid(uid))
636 : : return -EINVAL;
637 : 3 : newattrs.ia_valid |= ATTR_UID;
638 : 3 : newattrs.ia_uid = uid;
639 : : }
640 : 3 : if (group != (gid_t) -1) {
641 : 3 : if (!gid_valid(gid))
642 : : return -EINVAL;
643 : 3 : newattrs.ia_valid |= ATTR_GID;
644 : 3 : newattrs.ia_gid = gid;
645 : : }
646 : 3 : if (!S_ISDIR(inode->i_mode))
647 : 3 : newattrs.ia_valid |=
648 : : ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
649 : : inode_lock(inode);
650 : 3 : error = security_path_chown(path, uid, gid);
651 : 3 : if (!error)
652 : 3 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
653 : : inode_unlock(inode);
654 : 3 : if (delegated_inode) {
655 : 0 : error = break_deleg_wait(&delegated_inode);
656 : 0 : if (!error)
657 : : goto retry_deleg;
658 : : }
659 : 3 : return error;
660 : : }
661 : :
662 : 3 : int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
663 : : int flag)
664 : : {
665 : : struct path path;
666 : : int error = -EINVAL;
667 : : int lookup_flags;
668 : :
669 : 3 : if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
670 : : goto out;
671 : :
672 : 3 : lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
673 : 3 : if (flag & AT_EMPTY_PATH)
674 : 3 : lookup_flags |= LOOKUP_EMPTY;
675 : : retry:
676 : 3 : error = user_path_at(dfd, filename, lookup_flags, &path);
677 : 3 : if (error)
678 : : goto out;
679 : 3 : error = mnt_want_write(path.mnt);
680 : 3 : if (error)
681 : : goto out_release;
682 : 3 : error = chown_common(&path, user, group);
683 : 3 : mnt_drop_write(path.mnt);
684 : : out_release:
685 : 3 : path_put(&path);
686 : 3 : if (retry_estale(error, lookup_flags)) {
687 : 0 : lookup_flags |= LOOKUP_REVAL;
688 : 0 : goto retry;
689 : : }
690 : : out:
691 : 3 : return error;
692 : : }
693 : :
694 : 3 : SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
695 : : gid_t, group, int, flag)
696 : : {
697 : 3 : return do_fchownat(dfd, filename, user, group, flag);
698 : : }
699 : :
700 : 3 : SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
701 : : {
702 : 3 : return do_fchownat(AT_FDCWD, filename, user, group, 0);
703 : : }
704 : :
705 : 0 : SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
706 : : {
707 : 0 : return do_fchownat(AT_FDCWD, filename, user, group,
708 : : AT_SYMLINK_NOFOLLOW);
709 : : }
710 : :
711 : 3 : int ksys_fchown(unsigned int fd, uid_t user, gid_t group)
712 : : {
713 : : struct fd f = fdget(fd);
714 : : int error = -EBADF;
715 : :
716 : 3 : if (!f.file)
717 : : goto out;
718 : :
719 : 3 : error = mnt_want_write_file(f.file);
720 : 3 : if (error)
721 : : goto out_fput;
722 : 3 : audit_file(f.file);
723 : 3 : error = chown_common(&f.file->f_path, user, group);
724 : 3 : mnt_drop_write_file(f.file);
725 : : out_fput:
726 : : fdput(f);
727 : : out:
728 : 3 : return error;
729 : : }
730 : :
731 : 3 : SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
732 : : {
733 : 3 : return ksys_fchown(fd, user, group);
734 : : }
735 : :
736 : 3 : static int do_dentry_open(struct file *f,
737 : : struct inode *inode,
738 : : int (*open)(struct inode *, struct file *))
739 : : {
740 : : static const struct file_operations empty_fops = {};
741 : : int error;
742 : :
743 : 3 : path_get(&f->f_path);
744 : 3 : f->f_inode = inode;
745 : 3 : f->f_mapping = inode->i_mapping;
746 : :
747 : : /* Ensure that we skip any errors that predate opening of the file */
748 : 3 : f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
749 : :
750 : 3 : if (unlikely(f->f_flags & O_PATH)) {
751 : 3 : f->f_mode = FMODE_PATH | FMODE_OPENED;
752 : 3 : f->f_op = &empty_fops;
753 : 3 : return 0;
754 : : }
755 : :
756 : : /* Any file opened for execve()/uselib() has to be a regular file. */
757 : 3 : if (unlikely(f->f_flags & FMODE_EXEC && !S_ISREG(inode->i_mode))) {
758 : : error = -EACCES;
759 : : goto cleanup_file;
760 : : }
761 : :
762 : 3 : if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
763 : : error = get_write_access(inode);
764 : 3 : if (unlikely(error))
765 : : goto cleanup_file;
766 : 3 : error = __mnt_want_write(f->f_path.mnt);
767 : 3 : if (unlikely(error)) {
768 : : put_write_access(inode);
769 : : goto cleanup_file;
770 : : }
771 : 3 : f->f_mode |= FMODE_WRITER;
772 : : }
773 : :
774 : : /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
775 : 3 : if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
776 : 3 : f->f_mode |= FMODE_ATOMIC_POS;
777 : :
778 : 3 : f->f_op = fops_get(inode->i_fop);
779 : 3 : if (WARN_ON(!f->f_op)) {
780 : : error = -ENODEV;
781 : : goto cleanup_all;
782 : : }
783 : :
784 : 3 : error = security_file_open(f);
785 : 3 : if (error)
786 : : goto cleanup_all;
787 : :
788 : 3 : error = break_lease(locks_inode(f), f->f_flags);
789 : 3 : if (error)
790 : : goto cleanup_all;
791 : :
792 : : /* normally all 3 are set; ->open() can clear them if needed */
793 : 3 : f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
794 : 3 : if (!open)
795 : 3 : open = f->f_op->open;
796 : 3 : if (open) {
797 : 3 : error = open(inode, f);
798 : 3 : if (error)
799 : : goto cleanup_all;
800 : : }
801 : 3 : f->f_mode |= FMODE_OPENED;
802 : 3 : if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
803 : : i_readcount_inc(inode);
804 : 3 : if ((f->f_mode & FMODE_READ) &&
805 : 3 : likely(f->f_op->read || f->f_op->read_iter))
806 : 3 : f->f_mode |= FMODE_CAN_READ;
807 : 3 : if ((f->f_mode & FMODE_WRITE) &&
808 : 3 : likely(f->f_op->write || f->f_op->write_iter))
809 : 3 : f->f_mode |= FMODE_CAN_WRITE;
810 : :
811 : 3 : f->f_write_hint = WRITE_LIFE_NOT_SET;
812 : 3 : f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
813 : :
814 : 3 : file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
815 : :
816 : : /* NB: we're sure to have correct a_ops only after f_op->open */
817 : 3 : if (f->f_flags & O_DIRECT) {
818 : 0 : if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO)
819 : : return -EINVAL;
820 : : }
821 : :
822 : : /*
823 : : * XXX: Huge page cache doesn't support writing yet. Drop all page
824 : : * cache for this file before processing writes.
825 : : */
826 : : if ((f->f_mode & FMODE_WRITE) && filemap_nr_thps(inode->i_mapping))
827 : : truncate_pagecache(inode, 0);
828 : :
829 : 3 : return 0;
830 : :
831 : : cleanup_all:
832 : 3 : if (WARN_ON_ONCE(error > 0))
833 : : error = -EINVAL;
834 : 3 : fops_put(f->f_op);
835 : 3 : if (f->f_mode & FMODE_WRITER) {
836 : : put_write_access(inode);
837 : 0 : __mnt_drop_write(f->f_path.mnt);
838 : : }
839 : : cleanup_file:
840 : 3 : path_put(&f->f_path);
841 : 3 : f->f_path.mnt = NULL;
842 : 3 : f->f_path.dentry = NULL;
843 : 3 : f->f_inode = NULL;
844 : 3 : return error;
845 : : }
846 : :
847 : : /**
848 : : * finish_open - finish opening a file
849 : : * @file: file pointer
850 : : * @dentry: pointer to dentry
851 : : * @open: open callback
852 : : * @opened: state of open
853 : : *
854 : : * This can be used to finish opening a file passed to i_op->atomic_open().
855 : : *
856 : : * If the open callback is set to NULL, then the standard f_op->open()
857 : : * filesystem callback is substituted.
858 : : *
859 : : * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
860 : : * the return value of d_splice_alias(), then the caller needs to perform dput()
861 : : * on it after finish_open().
862 : : *
863 : : * Returns zero on success or -errno if the open failed.
864 : : */
865 : 3 : int finish_open(struct file *file, struct dentry *dentry,
866 : : int (*open)(struct inode *, struct file *))
867 : : {
868 : 3 : BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */
869 : :
870 : 3 : file->f_path.dentry = dentry;
871 : 3 : return do_dentry_open(file, d_backing_inode(dentry), open);
872 : : }
873 : : EXPORT_SYMBOL(finish_open);
874 : :
875 : : /**
876 : : * finish_no_open - finish ->atomic_open() without opening the file
877 : : *
878 : : * @file: file pointer
879 : : * @dentry: dentry or NULL (as returned from ->lookup())
880 : : *
881 : : * This can be used to set the result of a successful lookup in ->atomic_open().
882 : : *
883 : : * NB: unlike finish_open() this function does consume the dentry reference and
884 : : * the caller need not dput() it.
885 : : *
886 : : * Returns "0" which must be the return value of ->atomic_open() after having
887 : : * called this function.
888 : : */
889 : 0 : int finish_no_open(struct file *file, struct dentry *dentry)
890 : : {
891 : 0 : file->f_path.dentry = dentry;
892 : 0 : return 0;
893 : : }
894 : : EXPORT_SYMBOL(finish_no_open);
895 : :
896 : 0 : char *file_path(struct file *filp, char *buf, int buflen)
897 : : {
898 : 0 : return d_path(&filp->f_path, buf, buflen);
899 : : }
900 : : EXPORT_SYMBOL(file_path);
901 : :
902 : : /**
903 : : * vfs_open - open the file at the given path
904 : : * @path: path to open
905 : : * @file: newly allocated file with f_flag initialized
906 : : * @cred: credentials to use
907 : : */
908 : 3 : int vfs_open(const struct path *path, struct file *file)
909 : : {
910 : 3 : file->f_path = *path;
911 : 3 : return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
912 : : }
913 : :
914 : 3 : struct file *dentry_open(const struct path *path, int flags,
915 : : const struct cred *cred)
916 : : {
917 : : int error;
918 : : struct file *f;
919 : :
920 : : validate_creds(cred);
921 : :
922 : : /* We must always pass in a valid mount pointer. */
923 : 3 : BUG_ON(!path->mnt);
924 : :
925 : 3 : f = alloc_empty_file(flags, cred);
926 : 3 : if (!IS_ERR(f)) {
927 : : error = vfs_open(path, f);
928 : 3 : if (error) {
929 : 0 : fput(f);
930 : : f = ERR_PTR(error);
931 : : }
932 : : }
933 : 3 : return f;
934 : : }
935 : : EXPORT_SYMBOL(dentry_open);
936 : :
937 : 0 : struct file *open_with_fake_path(const struct path *path, int flags,
938 : : struct inode *inode, const struct cred *cred)
939 : : {
940 : 0 : struct file *f = alloc_empty_file_noaccount(flags, cred);
941 : 0 : if (!IS_ERR(f)) {
942 : : int error;
943 : :
944 : 0 : f->f_path = *path;
945 : 0 : error = do_dentry_open(f, inode, NULL);
946 : 0 : if (error) {
947 : 0 : fput(f);
948 : : f = ERR_PTR(error);
949 : : }
950 : : }
951 : 0 : return f;
952 : : }
953 : : EXPORT_SYMBOL(open_with_fake_path);
954 : :
955 : 3 : static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
956 : : {
957 : : int lookup_flags = 0;
958 : 3 : int acc_mode = ACC_MODE(flags);
959 : :
960 : : /*
961 : : * Clear out all open flags we don't know about so that we don't report
962 : : * them in fcntl(F_GETFD) or similar interfaces.
963 : : */
964 : : flags &= VALID_OPEN_FLAGS;
965 : :
966 : 3 : if (flags & (O_CREAT | __O_TMPFILE))
967 : 3 : op->mode = (mode & S_IALLUGO) | S_IFREG;
968 : : else
969 : 3 : op->mode = 0;
970 : :
971 : : /* Must never be set by userspace */
972 : 3 : flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
973 : :
974 : : /*
975 : : * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
976 : : * check for O_DSYNC if the need any syncing at all we enforce it's
977 : : * always set instead of having to deal with possibly weird behaviour
978 : : * for malicious applications setting only __O_SYNC.
979 : : */
980 : 3 : if (flags & __O_SYNC)
981 : 0 : flags |= O_DSYNC;
982 : :
983 : 3 : if (flags & __O_TMPFILE) {
984 : 3 : if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
985 : : return -EINVAL;
986 : 3 : if (!(acc_mode & MAY_WRITE))
987 : : return -EINVAL;
988 : 3 : } else if (flags & O_PATH) {
989 : : /*
990 : : * If we have O_PATH in the open flag. Then we
991 : : * cannot have anything other than the below set of flags
992 : : */
993 : 3 : flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
994 : : acc_mode = 0;
995 : : }
996 : :
997 : 3 : op->open_flag = flags;
998 : :
999 : : /* O_TRUNC implies we need access checks for write permissions */
1000 : 3 : if (flags & O_TRUNC)
1001 : 3 : acc_mode |= MAY_WRITE;
1002 : :
1003 : : /* Allow the LSM permission hook to distinguish append
1004 : : access from general write access. */
1005 : 3 : if (flags & O_APPEND)
1006 : 3 : acc_mode |= MAY_APPEND;
1007 : :
1008 : 3 : op->acc_mode = acc_mode;
1009 : :
1010 : 3 : op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
1011 : :
1012 : 3 : if (flags & O_CREAT) {
1013 : 3 : op->intent |= LOOKUP_CREATE;
1014 : 3 : if (flags & O_EXCL)
1015 : 3 : op->intent |= LOOKUP_EXCL;
1016 : : }
1017 : :
1018 : 3 : if (flags & O_DIRECTORY)
1019 : : lookup_flags |= LOOKUP_DIRECTORY;
1020 : 3 : if (!(flags & O_NOFOLLOW))
1021 : 3 : lookup_flags |= LOOKUP_FOLLOW;
1022 : 3 : op->lookup_flags = lookup_flags;
1023 : 3 : return 0;
1024 : : }
1025 : :
1026 : : /**
1027 : : * file_open_name - open file and return file pointer
1028 : : *
1029 : : * @name: struct filename containing path to open
1030 : : * @flags: open flags as per the open(2) second argument
1031 : : * @mode: mode for the new file if O_CREAT is set, else ignored
1032 : : *
1033 : : * This is the helper to open a file from kernelspace if you really
1034 : : * have to. But in generally you should not do this, so please move
1035 : : * along, nothing to see here..
1036 : : */
1037 : 3 : struct file *file_open_name(struct filename *name, int flags, umode_t mode)
1038 : : {
1039 : : struct open_flags op;
1040 : 3 : int err = build_open_flags(flags, mode, &op);
1041 : 3 : return err ? ERR_PTR(err) : do_filp_open(AT_FDCWD, name, &op);
1042 : : }
1043 : :
1044 : : /**
1045 : : * filp_open - open file and return file pointer
1046 : : *
1047 : : * @filename: path to open
1048 : : * @flags: open flags as per the open(2) second argument
1049 : : * @mode: mode for the new file if O_CREAT is set, else ignored
1050 : : *
1051 : : * This is the helper to open a file from kernelspace if you really
1052 : : * have to. But in generally you should not do this, so please move
1053 : : * along, nothing to see here..
1054 : : */
1055 : 3 : struct file *filp_open(const char *filename, int flags, umode_t mode)
1056 : : {
1057 : 3 : struct filename *name = getname_kernel(filename);
1058 : : struct file *file = ERR_CAST(name);
1059 : :
1060 : 3 : if (!IS_ERR(name)) {
1061 : 3 : file = file_open_name(name, flags, mode);
1062 : 3 : putname(name);
1063 : : }
1064 : 3 : return file;
1065 : : }
1066 : : EXPORT_SYMBOL(filp_open);
1067 : :
1068 : 0 : struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
1069 : : const char *filename, int flags, umode_t mode)
1070 : : {
1071 : : struct open_flags op;
1072 : 0 : int err = build_open_flags(flags, mode, &op);
1073 : 0 : if (err)
1074 : 0 : return ERR_PTR(err);
1075 : 0 : return do_file_open_root(dentry, mnt, filename, &op);
1076 : : }
1077 : : EXPORT_SYMBOL(file_open_root);
1078 : :
1079 : 3 : long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
1080 : : {
1081 : : struct open_flags op;
1082 : 3 : int fd = build_open_flags(flags, mode, &op);
1083 : : struct filename *tmp;
1084 : :
1085 : 3 : if (fd)
1086 : : return fd;
1087 : :
1088 : 3 : tmp = getname(filename);
1089 : 3 : if (IS_ERR(tmp))
1090 : 0 : return PTR_ERR(tmp);
1091 : :
1092 : 3 : fd = get_unused_fd_flags(flags);
1093 : 3 : if (fd >= 0) {
1094 : 3 : struct file *f = do_filp_open(dfd, tmp, &op);
1095 : 3 : if (IS_ERR(f)) {
1096 : 3 : put_unused_fd(fd);
1097 : : fd = PTR_ERR(f);
1098 : : } else {
1099 : 3 : fsnotify_open(f);
1100 : 3 : fd_install(fd, f);
1101 : : }
1102 : : }
1103 : 3 : putname(tmp);
1104 : 3 : return fd;
1105 : : }
1106 : :
1107 : 0 : SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1108 : : {
1109 : : if (force_o_largefile())
1110 : : flags |= O_LARGEFILE;
1111 : :
1112 : 0 : return do_sys_open(AT_FDCWD, filename, flags, mode);
1113 : : }
1114 : :
1115 : 3 : SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1116 : : umode_t, mode)
1117 : : {
1118 : : if (force_o_largefile())
1119 : : flags |= O_LARGEFILE;
1120 : :
1121 : 3 : return do_sys_open(dfd, filename, flags, mode);
1122 : : }
1123 : :
1124 : : #ifdef CONFIG_COMPAT
1125 : : /*
1126 : : * Exactly like sys_open(), except that it doesn't set the
1127 : : * O_LARGEFILE flag.
1128 : : */
1129 : : COMPAT_SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1130 : : {
1131 : : return do_sys_open(AT_FDCWD, filename, flags, mode);
1132 : : }
1133 : :
1134 : : /*
1135 : : * Exactly like sys_openat(), except that it doesn't set the
1136 : : * O_LARGEFILE flag.
1137 : : */
1138 : : COMPAT_SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags, umode_t, mode)
1139 : : {
1140 : : return do_sys_open(dfd, filename, flags, mode);
1141 : : }
1142 : : #endif
1143 : :
1144 : : #ifndef __alpha__
1145 : :
1146 : : /*
1147 : : * For backward compatibility? Maybe this should be moved
1148 : : * into arch/i386 instead?
1149 : : */
1150 : 3 : SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1151 : : {
1152 : : return ksys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1153 : : }
1154 : :
1155 : : #endif
1156 : :
1157 : : /*
1158 : : * "id" is the POSIX thread ID. We use the
1159 : : * files pointer for this..
1160 : : */
1161 : 3 : int filp_close(struct file *filp, fl_owner_t id)
1162 : : {
1163 : : int retval = 0;
1164 : :
1165 : 3 : if (!file_count(filp)) {
1166 : 0 : printk(KERN_ERR "VFS: Close: file count is 0\n");
1167 : 0 : return 0;
1168 : : }
1169 : :
1170 : 3 : if (filp->f_op->flush)
1171 : 0 : retval = filp->f_op->flush(filp, id);
1172 : :
1173 : 3 : if (likely(!(filp->f_mode & FMODE_PATH))) {
1174 : 3 : dnotify_flush(filp, id);
1175 : 3 : locks_remove_posix(filp, id);
1176 : : }
1177 : 3 : fput(filp);
1178 : 3 : return retval;
1179 : : }
1180 : :
1181 : : EXPORT_SYMBOL(filp_close);
1182 : :
1183 : : /*
1184 : : * Careful here! We test whether the file pointer is NULL before
1185 : : * releasing the fd. This ensures that one clone task can't release
1186 : : * an fd while another clone is opening it.
1187 : : */
1188 : 3 : SYSCALL_DEFINE1(close, unsigned int, fd)
1189 : : {
1190 : 3 : int retval = __close_fd(current->files, fd);
1191 : :
1192 : : /* can't restart close syscall because file table entry was cleared */
1193 : 3 : if (unlikely(retval == -ERESTARTSYS ||
1194 : : retval == -ERESTARTNOINTR ||
1195 : : retval == -ERESTARTNOHAND ||
1196 : : retval == -ERESTART_RESTARTBLOCK))
1197 : : retval = -EINTR;
1198 : :
1199 : 3 : return retval;
1200 : : }
1201 : :
1202 : : /*
1203 : : * This routine simulates a hangup on the tty, to arrange that users
1204 : : * are given clean terminals at login time.
1205 : : */
1206 : 0 : SYSCALL_DEFINE0(vhangup)
1207 : : {
1208 : 0 : if (capable(CAP_SYS_TTY_CONFIG)) {
1209 : 0 : tty_vhangup_self();
1210 : 0 : return 0;
1211 : : }
1212 : : return -EPERM;
1213 : : }
1214 : :
1215 : : /*
1216 : : * Called when an inode is about to be open.
1217 : : * We use this to disallow opening large files on 32bit systems if
1218 : : * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1219 : : * on this flag in sys_open.
1220 : : */
1221 : 3 : int generic_file_open(struct inode * inode, struct file * filp)
1222 : : {
1223 : 3 : if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1224 : : return -EOVERFLOW;
1225 : : return 0;
1226 : : }
1227 : :
1228 : : EXPORT_SYMBOL(generic_file_open);
1229 : :
1230 : : /*
1231 : : * This is used by subsystems that don't want seekable
1232 : : * file descriptors. The function is not supposed to ever fail, the only
1233 : : * reason it returns an 'int' and not 'void' is so that it can be plugged
1234 : : * directly into file_operations structure.
1235 : : */
1236 : 3 : int nonseekable_open(struct inode *inode, struct file *filp)
1237 : : {
1238 : 3 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1239 : 3 : return 0;
1240 : : }
1241 : :
1242 : : EXPORT_SYMBOL(nonseekable_open);
1243 : :
1244 : : /*
1245 : : * stream_open is used by subsystems that want stream-like file descriptors.
1246 : : * Such file descriptors are not seekable and don't have notion of position
1247 : : * (file.f_pos is always 0 and ppos passed to .read()/.write() is always NULL).
1248 : : * Contrary to file descriptors of other regular files, .read() and .write()
1249 : : * can run simultaneously.
1250 : : *
1251 : : * stream_open never fails and is marked to return int so that it could be
1252 : : * directly used as file_operations.open .
1253 : : */
1254 : 3 : int stream_open(struct inode *inode, struct file *filp)
1255 : : {
1256 : 3 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS);
1257 : 3 : filp->f_mode |= FMODE_STREAM;
1258 : 3 : return 0;
1259 : : }
1260 : :
1261 : : EXPORT_SYMBOL(stream_open);
|
