Branch data Line data Source code
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>
9 : : #include <linux/file.h>
10 : : #include <linux/fdtable.h>
11 : : #include <linux/fsnotify.h>
12 : : #include <linux/module.h>
13 : : #include <linux/tty.h>
14 : : #include <linux/namei.h>
15 : : #include <linux/backing-dev.h>
16 : : #include <linux/capability.h>
17 : : #include <linux/securebits.h>
18 : : #include <linux/security.h>
19 : : #include <linux/mount.h>
20 : : #include <linux/fcntl.h>
21 : : #include <linux/slab.h>
22 : : #include <asm/uaccess.h>
23 : : #include <linux/fs.h>
24 : : #include <linux/personality.h>
25 : : #include <linux/pagemap.h>
26 : : #include <linux/syscalls.h>
27 : : #include <linux/rcupdate.h>
28 : : #include <linux/audit.h>
29 : : #include <linux/falloc.h>
30 : : #include <linux/fs_struct.h>
31 : : #include <linux/ima.h>
32 : : #include <linux/dnotify.h>
33 : : #include <linux/compat.h>
34 : :
35 : : #include "internal.h"
36 : :
37 : 0 : int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
38 : : struct file *filp)
39 : : {
40 : : int ret;
41 : : struct iattr newattrs;
42 : :
43 : : /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
44 [ + + ]: 39513 : if (length < 0)
45 : : return -EINVAL;
46 : :
47 : 39512 : newattrs.ia_size = length;
48 : 39512 : newattrs.ia_valid = ATTR_SIZE | time_attrs;
49 [ + + ]: 39512 : if (filp) {
50 : 37826 : newattrs.ia_file = filp;
51 : 37826 : newattrs.ia_valid |= ATTR_FILE;
52 : : }
53 : :
54 : : /* Remove suid/sgid on truncate too */
55 : 39512 : ret = should_remove_suid(dentry);
56 [ - + ]: 39511 : if (ret)
57 : 0 : newattrs.ia_valid |= ret | ATTR_FORCE;
58 : :
59 : 39511 : mutex_lock(&dentry->d_inode->i_mutex);
60 : : /* Note any delegations or leases have already been broken: */
61 : 39512 : ret = notify_change(dentry, &newattrs, NULL);
62 : 39513 : mutex_unlock(&dentry->d_inode->i_mutex);
63 : 39513 : return ret;
64 : : }
65 : :
66 : 0 : long vfs_truncate(struct path *path, loff_t length)
67 : : {
68 : : struct inode *inode;
69 : : long error;
70 : :
71 : 1690 : inode = path->dentry->d_inode;
72 : :
73 : : /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
74 [ + + ]: 1690 : if (S_ISDIR(inode->i_mode))
75 : : return -EISDIR;
76 [ + - ]: 1687 : if (!S_ISREG(inode->i_mode))
77 : : return -EINVAL;
78 : :
79 : 1687 : error = mnt_want_write(path->mnt);
80 [ + + ]: 1687 : if (error)
81 : : goto out;
82 : :
83 : 1685 : error = inode_permission(inode, MAY_WRITE);
84 [ + + ]: 1687 : if (error)
85 : : goto mnt_drop_write_and_out;
86 : :
87 : : error = -EPERM;
88 [ + + ]: 1686 : if (IS_APPEND(inode))
89 : : goto mnt_drop_write_and_out;
90 : :
91 : : error = get_write_access(inode);
92 [ + ]: 1684 : if (error)
93 : : goto mnt_drop_write_and_out;
94 : :
95 : : /*
96 : : * Make sure that there are no leases. get_write_access() protects
97 : : * against the truncate racing with a lease-granting setlease().
98 : : */
99 : : error = break_lease(inode, O_WRONLY);
100 [ + - ]: 1684 : if (error)
101 : : goto put_write_and_out;
102 : :
103 : : error = locks_verify_truncate(inode, NULL, length);
104 [ + ]: 1681 : if (!error)
105 : 1686 : error = security_path_truncate(path);
106 [ + - ]: 1681 : if (!error)
107 : 1681 : error = do_truncate(path->dentry, length, 0, NULL);
108 : :
109 : : put_write_and_out:
110 : : put_write_access(inode);
111 : : mnt_drop_write_and_out:
112 : 1689 : mnt_drop_write(path->mnt);
113 : : out:
114 : 1688 : return error;
115 : : }
116 : : EXPORT_SYMBOL_GPL(vfs_truncate);
117 : :
118 : 0 : static long do_sys_truncate(const char __user *pathname, loff_t length)
119 : : {
120 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
121 : : struct path path;
122 : : int error;
123 : :
124 [ + + ]: 1700 : if (length < 0) /* sorry, but loff_t says... */
125 : : return -EINVAL;
126 : :
127 : : retry:
128 : 1699 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
129 [ + + ]: 1700 : if (!error) {
130 : 1689 : error = vfs_truncate(&path, length);
131 : 1690 : path_put(&path);
132 : : }
133 [ - + ]: 1700 : if (retry_estale(error, lookup_flags)) {
134 : : lookup_flags |= LOOKUP_REVAL;
135 : : goto retry;
136 : : }
137 : : return error;
138 : : }
139 : :
140 : 0 : SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
141 : : {
142 : 1680 : return do_sys_truncate(path, length);
143 : : }
144 : :
145 : : #ifdef CONFIG_COMPAT
146 : : COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length)
147 : : {
148 : : return do_sys_truncate(path, length);
149 : : }
150 : : #endif
151 : :
152 : 0 : static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
153 : : {
154 : : struct inode *inode;
155 : : struct dentry *dentry;
156 : : struct fd f;
157 : : int error;
158 : :
159 : : error = -EINVAL;
160 [ + - ]: 30657 : if (length < 0)
161 : : goto out;
162 : : error = -EBADF;
163 : : f = fdget(fd);
164 [ + + ]: 30657 : if (!f.file)
165 : : goto out;
166 : :
167 : : /* explicitly opened as large or we are on 64-bit box */
168 [ + + ]: 30655 : if (f.file->f_flags & O_LARGEFILE)
169 : : small = 0;
170 : :
171 : 30655 : dentry = f.file->f_path.dentry;
172 : 30655 : inode = dentry->d_inode;
173 : : error = -EINVAL;
174 [ + + ][ + + ]: 30655 : if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
175 : : goto out_putf;
176 : :
177 : : error = -EINVAL;
178 : : /* Cannot ftruncate over 2^31 bytes without large file support */
179 [ + - ]: 30650 : if (small && length > MAX_NON_LFS)
180 : : goto out_putf;
181 : :
182 : : error = -EPERM;
183 [ + - ]: 30650 : if (IS_APPEND(inode))
184 : : goto out_putf;
185 : :
186 : 30650 : sb_start_write(inode->i_sb);
187 : : error = locks_verify_truncate(inode, f.file, length);
188 [ + + ]: 61308 : if (!error)
189 : 30631 : error = security_path_truncate(&f.file->f_path);
190 [ + + ]: 30650 : if (!error)
191 : 30630 : error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
192 : 30651 : sb_end_write(inode->i_sb);
193 : : out_putf:
194 : : fdput(f);
195 : : out:
196 : 30657 : return error;
197 : : }
198 : :
199 : 0 : SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
200 : : {
201 : 30547 : return do_sys_ftruncate(fd, length, 1);
202 : : }
203 : :
204 : : #ifdef CONFIG_COMPAT
205 : : COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
206 : : {
207 : : return do_sys_ftruncate(fd, length, 1);
208 : : }
209 : : #endif
210 : :
211 : : /* LFS versions of truncate are only needed on 32 bit machines */
212 : : #if BITS_PER_LONG == 32
213 : 0 : SYSCALL_DEFINE2(truncate64, const char __user *, path, loff_t, length)
214 : : {
215 : 20 : return do_sys_truncate(path, length);
216 : : }
217 : :
218 : 0 : SYSCALL_DEFINE2(ftruncate64, unsigned int, fd, loff_t, length)
219 : : {
220 : 110 : return do_sys_ftruncate(fd, length, 0);
221 : : }
222 : : #endif /* BITS_PER_LONG == 32 */
223 : :
224 : :
225 : 0 : int do_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
226 : : {
227 : : struct inode *inode = file_inode(file);
228 : : long ret;
229 : :
230 [ + + ]: 22 : if (offset < 0 || len <= 0)
231 : : return -EINVAL;
232 : :
233 : : /* Return error if mode is not supported */
234 [ + - ]: 17 : if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
235 : : return -EOPNOTSUPP;
236 : :
237 : : /* Punch hole must have keep size set */
238 [ + - ]: 17 : if ((mode & FALLOC_FL_PUNCH_HOLE) &&
239 : : !(mode & FALLOC_FL_KEEP_SIZE))
240 : : return -EOPNOTSUPP;
241 : :
242 [ + + ]: 17 : if (!(file->f_mode & FMODE_WRITE))
243 : : return -EBADF;
244 : :
245 : : /* It's not possible punch hole on append only file */
246 [ + + ][ + - ]: 16 : if (mode & FALLOC_FL_PUNCH_HOLE && IS_APPEND(inode))
247 : : return -EPERM;
248 : :
249 [ + - ]: 16 : if (IS_IMMUTABLE(inode))
250 : : return -EPERM;
251 : :
252 : : /*
253 : : * Revalidate the write permissions, in case security policy has
254 : : * changed since the files were opened.
255 : : */
256 : 16 : ret = security_file_permission(file, MAY_WRITE);
257 [ + - ]: 16 : if (ret)
258 : : return ret;
259 : :
260 [ + - ]: 16 : if (S_ISFIFO(inode->i_mode))
261 : : return -ESPIPE;
262 : :
263 : : /*
264 : : * Let individual file system decide if it supports preallocation
265 : : * for directories or not.
266 : : */
267 [ + - ]: 16 : if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
268 : : return -ENODEV;
269 : :
270 : : /* Check for wrap through zero too */
271 [ + - ][ + + ]: 16 : if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
272 : : return -EFBIG;
273 : :
274 [ + - ]: 14 : if (!file->f_op->fallocate)
275 : : return -EOPNOTSUPP;
276 : :
277 : : sb_start_write(inode->i_sb);
278 : 14 : ret = file->f_op->fallocate(file, mode, offset, len);
279 : 14 : sb_end_write(inode->i_sb);
280 : 14 : return ret;
281 : : }
282 : :
283 : 0 : SYSCALL_DEFINE4(fallocate, int, fd, int, mode, loff_t, offset, loff_t, len)
284 : : {
285 : 21 : struct fd f = fdget(fd);
286 : : int error = -EBADF;
287 : :
288 [ + - ]: 21 : if (f.file) {
289 : 21 : error = do_fallocate(f.file, mode, offset, len);
290 : : fdput(f);
291 : : }
292 : : return error;
293 : : }
294 : :
295 : : /*
296 : : * access() needs to use the real uid/gid, not the effective uid/gid.
297 : : * We do this by temporarily clearing all FS-related capabilities and
298 : : * switching the fsuid/fsgid around to the real ones.
299 : : */
300 : 0 : SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
301 : : {
302 : : const struct cred *old_cred;
303 : : struct cred *override_cred;
304 : : struct path path;
305 : : struct inode *inode;
306 : : int res;
307 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
308 : :
309 [ + + ]: 466203 : if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
310 : : return -EINVAL;
311 : :
312 : 466201 : override_cred = prepare_creds();
313 [ + + ]: 466200 : if (!override_cred)
314 : : return -ENOMEM;
315 : :
316 : 466199 : override_cred->fsuid = override_cred->uid;
317 : 466199 : override_cred->fsgid = override_cred->gid;
318 : :
319 [ + ]: 466199 : if (!issecure(SECURE_NO_SETUID_FIXUP)) {
320 : : /* Clear the capabilities if we switch to a non-root user */
321 : : kuid_t root_uid = make_kuid(override_cred->user_ns, 0);
322 [ + + ]: 466201 : if (!uid_eq(override_cred->uid, root_uid))
323 : 1113 : cap_clear(override_cred->cap_effective);
324 : : else
325 : 465088 : override_cred->cap_effective =
326 : : override_cred->cap_permitted;
327 : : }
328 : :
329 : 466199 : old_cred = override_creds(override_cred);
330 : : retry:
331 : 466192 : res = user_path_at(dfd, filename, lookup_flags, &path);
332 [ + + ]: 466201 : if (res)
333 : : goto out;
334 : :
335 : 65595 : inode = path.dentry->d_inode;
336 : :
337 [ + + ][ + + ]: 65595 : if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
338 : : /*
339 : : * MAY_EXEC on regular files is denied if the fs is mounted
340 : : * with the "noexec" flag.
341 : : */
342 : : res = -EACCES;
343 [ + - ]: 28669 : if (path.mnt->mnt_flags & MNT_NOEXEC)
344 : : goto out_path_release;
345 : : }
346 : :
347 : 65595 : res = inode_permission(inode, mode | MAY_ACCESS);
348 : : /* SuS v2 requires we report a read only fs too */
349 [ + + ][ + + ]: 65595 : if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
[ + + ][ + - ]
[ + - ]
350 : : goto out_path_release;
351 : : /*
352 : : * This is a rare case where using __mnt_is_readonly()
353 : : * is OK without a mnt_want/drop_write() pair. Since
354 : : * no actual write to the fs is performed here, we do
355 : : * not need to telegraph to that to anyone.
356 : : *
357 : : * By doing this, we accept that this access is
358 : : * inherently racy and know that the fs may change
359 : : * state before we even see this result.
360 : : */
361 [ - + ]: 4593 : if (__mnt_is_readonly(path.mnt))
362 : : res = -EROFS;
363 : :
364 : : out_path_release:
365 : 65595 : path_put(&path);
366 [ - + ]: 65594 : if (retry_estale(res, lookup_flags)) {
367 : : lookup_flags |= LOOKUP_REVAL;
368 : : goto retry;
369 : : }
370 : : out:
371 : 466200 : revert_creds(old_cred);
372 : : put_cred(override_cred);
373 : : return res;
374 : : }
375 : :
376 : 0 : SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
377 : : {
378 : 464845 : return sys_faccessat(AT_FDCWD, filename, mode);
379 : : }
380 : :
381 : 12828 : SYSCALL_DEFINE1(chdir, const char __user *, filename)
382 : : {
383 : : struct path path;
384 : : int error;
385 : : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
386 : : retry:
387 : 12828 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
388 [ + + ]: 12828 : if (error)
389 : : goto out;
390 : :
391 : 12804 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
392 [ + + ]: 12804 : if (error)
393 : : goto dput_and_out;
394 : :
395 : 12803 : set_fs_pwd(current->fs, &path);
396 : :
397 : : dput_and_out:
398 : 12804 : path_put(&path);
399 [ - + ]: 12804 : if (retry_estale(error, lookup_flags)) {
400 : : lookup_flags |= LOOKUP_REVAL;
401 : : goto retry;
402 : : }
403 : : out:
404 : : return error;
405 : : }
406 : :
407 : 0 : SYSCALL_DEFINE1(fchdir, unsigned int, fd)
408 : : {
409 : : struct fd f = fdget_raw(fd);
410 : : struct inode *inode;
411 : : int error = -EBADF;
412 : :
413 : : error = -EBADF;
414 [ + + ]: 3731 : if (!f.file)
415 : : goto out;
416 : :
417 : : inode = file_inode(f.file);
418 : :
419 : : error = -ENOTDIR;
420 [ + - ]: 3730 : if (!S_ISDIR(inode->i_mode))
421 : : goto out_putf;
422 : :
423 : 3730 : error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
424 [ + + ]: 3730 : if (!error)
425 : 3729 : set_fs_pwd(current->fs, &f.file->f_path);
426 : : out_putf:
427 : : fdput(f);
428 : : out:
429 : : return error;
430 : : }
431 : :
432 : 9 : SYSCALL_DEFINE1(chroot, const char __user *, filename)
433 : : {
434 : : struct path path;
435 : : int error;
436 : : unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
437 : : retry:
438 : 9 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
439 [ + + ]: 9 : if (error)
440 : : goto out;
441 : :
442 : 4 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
443 [ + + ]: 4 : if (error)
444 : : goto dput_and_out;
445 : :
446 : : error = -EPERM;
447 [ + + ]: 3 : if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
448 : : goto dput_and_out;
449 : 2 : error = security_path_chroot(&path);
450 [ + - ]: 2 : if (error)
451 : : goto dput_and_out;
452 : :
453 : 2 : set_fs_root(current->fs, &path);
454 : : error = 0;
455 : : dput_and_out:
456 : 4 : path_put(&path);
457 [ - + ]: 4 : if (retry_estale(error, lookup_flags)) {
458 : : lookup_flags |= LOOKUP_REVAL;
459 : : goto retry;
460 : : }
461 : : out:
462 : : return error;
463 : : }
464 : :
465 : 0 : static int chmod_common(struct path *path, umode_t mode)
466 : : {
467 : 17021 : struct inode *inode = path->dentry->d_inode;
468 : 17021 : struct inode *delegated_inode = NULL;
469 : : struct iattr newattrs;
470 : : int error;
471 : :
472 : 17021 : error = mnt_want_write(path->mnt);
473 [ + - ]: 17021 : if (error)
474 : : return error;
475 : : retry_deleg:
476 : 17021 : mutex_lock(&inode->i_mutex);
477 : 17021 : error = security_path_chmod(path, mode);
478 [ + - ]: 17021 : if (error)
479 : : goto out_unlock;
480 : 17021 : newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
481 : 17021 : newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
482 : 17021 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
483 : : out_unlock:
484 : 17021 : mutex_unlock(&inode->i_mutex);
485 [ - + ]: 17021 : if (delegated_inode) {
486 : : error = break_deleg_wait(&delegated_inode);
487 [ # # ]: 0 : if (!error)
488 : : goto retry_deleg;
489 : : }
490 : 17021 : mnt_drop_write(path->mnt);
491 : 17021 : return error;
492 : : }
493 : :
494 : 0 : SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
495 : : {
496 : : struct fd f = fdget(fd);
497 : : int err = -EBADF;
498 : :
499 [ + - ]: 5081 : if (f.file) {
500 : 5081 : audit_inode(NULL, f.file->f_path.dentry, 0);
501 : 5081 : err = chmod_common(&f.file->f_path, mode);
502 : : fdput(f);
503 : : }
504 : : return err;
505 : : }
506 : :
507 : 11946 : SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, umode_t, mode)
508 : : {
509 : : struct path path;
510 : : int error;
511 : : unsigned int lookup_flags = LOOKUP_FOLLOW;
512 : : retry:
513 : 11946 : error = user_path_at(dfd, filename, lookup_flags, &path);
514 [ + + ]: 11946 : if (!error) {
515 : 11940 : error = chmod_common(&path, mode);
516 : 11940 : path_put(&path);
517 [ - ]: 11940 : if (retry_estale(error, lookup_flags)) {
518 : : lookup_flags |= LOOKUP_REVAL;
519 : : goto retry;
520 : : }
521 : : }
522 : : return error;
523 : : }
524 : :
525 : 0 : SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
526 : : {
527 : 11814 : return sys_fchmodat(AT_FDCWD, filename, mode);
528 : : }
529 : :
530 : 0 : static int chown_common(struct path *path, uid_t user, gid_t group)
531 : : {
532 : 3588 : struct inode *inode = path->dentry->d_inode;
533 : 3588 : struct inode *delegated_inode = NULL;
534 : : int error;
535 : : struct iattr newattrs;
536 : : kuid_t uid;
537 : : kgid_t gid;
538 : :
539 : : uid = make_kuid(current_user_ns(), user);
540 : : gid = make_kgid(current_user_ns(), group);
541 : :
542 : 3588 : newattrs.ia_valid = ATTR_CTIME;
543 [ + + ]: 3588 : if (user != (uid_t) -1) {
544 [ + - ]: 2830 : if (!uid_valid(uid))
545 : : return -EINVAL;
546 : 2830 : newattrs.ia_valid |= ATTR_UID;
547 : 2830 : newattrs.ia_uid = uid;
548 : : }
549 [ + + ]: 3588 : if (group != (gid_t) -1) {
550 [ + - ]: 3550 : if (!gid_valid(gid))
551 : : return -EINVAL;
552 : 3550 : newattrs.ia_valid |= ATTR_GID;
553 : 3550 : newattrs.ia_gid = gid;
554 : : }
555 [ + + ]: 3588 : if (!S_ISDIR(inode->i_mode))
556 : 3588 : newattrs.ia_valid |=
557 : : ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
558 : : retry_deleg:
559 : 3588 : mutex_lock(&inode->i_mutex);
560 : 3588 : error = security_path_chown(path, uid, gid);
561 [ + - ]: 3588 : if (!error)
562 : 3588 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
563 : 3588 : mutex_unlock(&inode->i_mutex);
564 [ - + ]: 7176 : if (delegated_inode) {
565 : : error = break_deleg_wait(&delegated_inode);
566 [ # # ]: 0 : if (!error)
567 : : goto retry_deleg;
568 : : }
569 : 3588 : return error;
570 : : }
571 : :
572 : 0 : SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
573 : : gid_t, group, int, flag)
574 : : {
575 : : struct path path;
576 : : int error = -EINVAL;
577 : : int lookup_flags;
578 : :
579 [ + + ]: 1216 : if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
580 : : goto out;
581 : :
582 : 1215 : lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
583 [ - + ]: 1215 : if (flag & AT_EMPTY_PATH)
584 : 1215 : lookup_flags |= LOOKUP_EMPTY;
585 : : retry:
586 : 1215 : error = user_path_at(dfd, filename, lookup_flags, &path);
587 [ + + ]: 1215 : if (error)
588 : : goto out;
589 : 1201 : error = mnt_want_write(path.mnt);
590 [ + - ]: 1201 : if (error)
591 : : goto out_release;
592 : 1201 : error = chown_common(&path, user, group);
593 : 1201 : mnt_drop_write(path.mnt);
594 : : out_release:
595 : 1201 : path_put(&path);
596 [ - + ]: 1201 : if (retry_estale(error, lookup_flags)) {
597 : 0 : lookup_flags |= LOOKUP_REVAL;
598 : : goto retry;
599 : : }
600 : : out:
601 : : return error;
602 : : }
603 : :
604 : 0 : SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
605 : : {
606 : 1121 : return sys_fchownat(AT_FDCWD, filename, user, group, 0);
607 : : }
608 : :
609 : 0 : SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
610 : : {
611 : 41 : return sys_fchownat(AT_FDCWD, filename, user, group,
612 : : AT_SYMLINK_NOFOLLOW);
613 : : }
614 : :
615 : 0 : SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
616 : : {
617 : : struct fd f = fdget(fd);
618 : : int error = -EBADF;
619 : :
620 [ + + ]: 2389 : if (!f.file)
621 : : goto out;
622 : :
623 : 2387 : error = mnt_want_write_file(f.file);
624 [ + - ]: 2387 : if (error)
625 : : goto out_fput;
626 : 2387 : audit_inode(NULL, f.file->f_path.dentry, 0);
627 : 2387 : error = chown_common(&f.file->f_path, user, group);
628 : 2387 : mnt_drop_write_file(f.file);
629 : : out_fput:
630 : : fdput(f);
631 : : out:
632 : : return error;
633 : : }
634 : :
635 : : /*
636 : : * You have to be very careful that these write
637 : : * counts get cleaned up in error cases and
638 : : * upon __fput(). This should probably never
639 : : * be called outside of __dentry_open().
640 : : */
641 : : static inline int __get_file_write_access(struct inode *inode,
642 : : struct vfsmount *mnt)
643 : : {
644 : : int error;
645 : : error = get_write_access(inode);
646 [ + ]: 2033817 : if (error)
647 : : return error;
648 : : /*
649 : : * Do not take mount writer counts on
650 : : * special files since no writes to
651 : : * the mount itself will occur.
652 : : */
653 [ + + ][ + + ]: 2033832 : if (!special_file(inode->i_mode)) {
[ + - ]
654 : : /*
655 : : * Balanced in __fput()
656 : : */
657 : 1561609 : error = __mnt_want_write(mnt);
658 [ - + ]: 1561609 : if (error)
659 : : put_write_access(inode);
660 : : }
661 : : return error;
662 : : }
663 : :
664 : 0 : int open_check_o_direct(struct file *f)
665 : : {
666 : : /* NB: we're sure to have correct a_ops only after f_op->open */
667 [ - + ][ + + ]: 3509699 : if (f->f_flags & O_DIRECT) {
668 [ # # ][ # # ]: 146 : if (!f->f_mapping->a_ops ||
[ + - ][ + + ]
669 [ # # ][ + ]: 35 : ((!f->f_mapping->a_ops->direct_IO) &&
670 : 2 : (!f->f_mapping->a_ops->get_xip_mem))) {
671 : : return -EINVAL;
672 : : }
673 : : }
674 : 3509639 : return 0;
675 : : }
676 : :
677 : 0 : static int do_dentry_open(struct file *f,
678 : : int (*open)(struct inode *, struct file *),
679 : : const struct cred *cred)
680 : : {
681 : : static const struct file_operations empty_fops = {};
682 : : struct inode *inode;
683 : : int error;
684 : :
685 : 7019544 : f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
686 : 3509772 : FMODE_PREAD | FMODE_PWRITE;
687 : :
688 [ - + ]: 3509772 : if (unlikely(f->f_flags & O_PATH))
689 : 0 : f->f_mode = FMODE_PATH;
690 : :
691 : 3509772 : path_get(&f->f_path);
692 : 3509730 : inode = f->f_inode = f->f_path.dentry->d_inode;
693 [ + + ]: 3509730 : if (f->f_mode & FMODE_WRITE) {
694 : 2033827 : error = __get_file_write_access(inode, f->f_path.mnt);
695 [ + + ]: 2033819 : if (error)
696 : : goto cleanup_file;
697 : : if (!special_file(inode->i_mode))
698 : : file_take_write(f);
699 : : }
700 : :
701 : 3509721 : f->f_mapping = inode->i_mapping;
702 : :
703 [ - + ]: 3509721 : if (unlikely(f->f_mode & FMODE_PATH)) {
704 : 0 : f->f_op = &empty_fops;
705 : 0 : return 0;
706 : : }
707 : :
708 [ + + ][ + ]: 3509721 : f->f_op = fops_get(inode->i_fop);
709 [ - + ][ + + ]: 3509712 : if (unlikely(WARN_ON(!f->f_op))) {
710 : : error = -ENODEV;
711 : : goto cleanup_all;
712 : : }
713 : :
714 : 3509733 : error = security_file_open(f, cred);
715 [ + ]: 3509632 : if (error)
716 : : goto cleanup_all;
717 : :
718 : 3509650 : error = break_lease(inode, f->f_flags);
719 [ + - ]: 3509683 : if (error)
720 : : goto cleanup_all;
721 : :
722 [ + + ]: 3509683 : if (!open)
723 : 3509588 : open = f->f_op->open;
724 [ + + ]: 3509683 : if (open) {
725 : 3438150 : error = open(inode, f);
726 [ + + ]: 3437990 : if (error)
727 : : goto cleanup_all;
728 : : }
729 : : if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
730 : : i_readcount_inc(inode);
731 : :
732 : 3509517 : f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
733 : :
734 : 3509517 : file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
735 : :
736 : 3509527 : return 0;
737 : :
738 : : cleanup_all:
739 [ + - ]: 39 : fops_put(f->f_op);
740 [ + - ]: 39 : if (f->f_mode & FMODE_WRITE) {
741 : : put_write_access(inode);
742 [ + + ][ - + ]: 39 : if (!special_file(inode->i_mode)) {
[ # # ]
743 : : /*
744 : : * We don't consider this a real
745 : : * mnt_want/drop_write() pair
746 : : * because it all happenend right
747 : : * here, so just reset the state.
748 : : */
749 : : file_reset_write(f);
750 : 0 : __mnt_drop_write(f->f_path.mnt);
751 : : }
752 : : }
753 : : cleanup_file:
754 : 40 : path_put(&f->f_path);
755 : 40 : f->f_path.mnt = NULL;
756 : 40 : f->f_path.dentry = NULL;
757 : 40 : f->f_inode = NULL;
758 : 40 : return error;
759 : : }
760 : :
761 : : /**
762 : : * finish_open - finish opening a file
763 : : * @file: file pointer
764 : : * @dentry: pointer to dentry
765 : : * @open: open callback
766 : : * @opened: state of open
767 : : *
768 : : * This can be used to finish opening a file passed to i_op->atomic_open().
769 : : *
770 : : * If the open callback is set to NULL, then the standard f_op->open()
771 : : * filesystem callback is substituted.
772 : : *
773 : : * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
774 : : * the return value of d_splice_alias(), then the caller needs to perform dput()
775 : : * on it after finish_open().
776 : : *
777 : : * On successful return @file is a fully instantiated open file. After this, if
778 : : * an error occurs in ->atomic_open(), it needs to clean up with fput().
779 : : *
780 : : * Returns zero on success or -errno if the open failed.
781 : : */
782 : 0 : int finish_open(struct file *file, struct dentry *dentry,
783 : : int (*open)(struct inode *, struct file *),
784 : : int *opened)
785 : : {
786 : : int error;
787 [ - + ]: 3509740 : BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
788 : :
789 : 3509740 : file->f_path.dentry = dentry;
790 : 3509740 : error = do_dentry_open(file, open, current_cred());
791 [ + + ]: 3509521 : if (!error)
792 : 3509480 : *opened |= FILE_OPENED;
793 : :
794 : 0 : return error;
795 : : }
796 : : EXPORT_SYMBOL(finish_open);
797 : :
798 : : /**
799 : : * finish_no_open - finish ->atomic_open() without opening the file
800 : : *
801 : : * @file: file pointer
802 : : * @dentry: dentry or NULL (as returned from ->lookup())
803 : : *
804 : : * This can be used to set the result of a successful lookup in ->atomic_open().
805 : : *
806 : : * NB: unlike finish_open() this function does consume the dentry reference and
807 : : * the caller need not dput() it.
808 : : *
809 : : * Returns "1" which must be the return value of ->atomic_open() after having
810 : : * called this function.
811 : : */
812 : 0 : int finish_no_open(struct file *file, struct dentry *dentry)
813 : : {
814 : 0 : file->f_path.dentry = dentry;
815 : 0 : return 1;
816 : : }
817 : : EXPORT_SYMBOL(finish_no_open);
818 : :
819 : 0 : struct file *dentry_open(const struct path *path, int flags,
820 : : const struct cred *cred)
821 : : {
822 : : int error;
823 : : struct file *f;
824 : :
825 : : validate_creds(cred);
826 : :
827 : : /* We must always pass in a valid mount pointer. */
828 [ - + ]: 33 : BUG_ON(!path->mnt);
829 : :
830 : 33 : f = get_empty_filp();
831 [ + - ]: 33 : if (!IS_ERR(f)) {
832 : 33 : f->f_flags = flags;
833 : 33 : f->f_path = *path;
834 : 33 : error = do_dentry_open(f, NULL, cred);
835 [ + - ]: 33 : if (!error) {
836 : : /* from now on we need fput() to dispose of f */
837 : : error = open_check_o_direct(f);
838 [ - + ]: 33 : if (error) {
839 : 0 : fput(f);
840 : : f = ERR_PTR(error);
841 : : }
842 : : } else {
843 : 0 : put_filp(f);
844 : : f = ERR_PTR(error);
845 : : }
846 : : }
847 : 0 : return f;
848 : : }
849 : : EXPORT_SYMBOL(dentry_open);
850 : :
851 : : static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
852 : : {
853 : : int lookup_flags = 0;
854 : : int acc_mode;
855 : :
856 [ + + ][ # # ]: 5921035 : if (flags & (O_CREAT | __O_TMPFILE))
[ + + ]
857 : 1982142 : op->mode = (mode & S_IALLUGO) | S_IFREG;
858 : : else
859 : 3938893 : op->mode = 0;
860 : :
861 : : /* Must never be set by userspace */
862 : 5921035 : flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
863 : :
864 : : /*
865 : : * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
866 : : * check for O_DSYNC if the need any syncing at all we enforce it's
867 : : * always set instead of having to deal with possibly weird behaviour
868 : : * for malicious applications setting only __O_SYNC.
869 : : */
870 [ + + ][ # # ]: 5921035 : if (flags & __O_SYNC)
[ - + ]
871 : 59 : flags |= O_DSYNC;
872 : :
873 [ - + ][ # # ]: 5921035 : if (flags & __O_TMPFILE) {
[ - + ]
874 [ # # ][ # # ]: 0 : if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
[ # # ]
875 : : return -EINVAL;
876 : 0 : acc_mode = MAY_OPEN | ACC_MODE(flags);
877 [ # # ][ # # ]: 0 : if (!(acc_mode & MAY_WRITE))
[ # # ]
878 : : return -EINVAL;
879 [ - + ][ # # ]: 5921035 : } else if (flags & O_PATH) {
[ - + ]
880 : : /*
881 : : * If we have O_PATH in the open flag. Then we
882 : : * cannot have anything other than the below set of flags
883 : : */
884 : 0 : flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
885 : : acc_mode = 0;
886 : : } else {
887 : 5921035 : acc_mode = MAY_OPEN | ACC_MODE(flags);
888 : : }
889 : :
890 : 11841993 : op->open_flag = flags;
891 : :
892 : : /* O_TRUNC implies we need access checks for write permissions */
893 [ + + ][ # # ]: 11841993 : if (flags & O_TRUNC)
[ - + ]
894 : 331834 : acc_mode |= MAY_WRITE;
895 : :
896 : : /* Allow the LSM permission hook to distinguish append
897 : : access from general write access. */
898 [ + + ][ # # ]: 11841993 : if (flags & O_APPEND)
[ + + ]
899 : 4463 : acc_mode |= MAY_APPEND;
900 : :
901 : 5921050 : op->acc_mode = acc_mode;
902 : :
903 [ + + ][ # # ]: 5921050 : op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
[ + - ]
904 : :
905 [ + + ][ # # ]: 5921050 : if (flags & O_CREAT) {
[ + + ]
906 : 1982150 : op->intent |= LOOKUP_CREATE;
907 [ + + ][ # # ]: 1982150 : if (flags & O_EXCL)
[ - + ]
908 : 13821 : op->intent |= LOOKUP_EXCL;
909 : : }
910 : :
911 [ + + ][ # # ]: 5921050 : if (flags & O_DIRECTORY)
[ - + ]
912 : : lookup_flags |= LOOKUP_DIRECTORY;
913 [ + + ][ # # ]: 5921050 : if (!(flags & O_NOFOLLOW))
[ + + ]
914 : 5908591 : lookup_flags |= LOOKUP_FOLLOW;
915 : 5921050 : op->lookup_flags = lookup_flags;
916 : : return 0;
917 : : }
918 : :
919 : : /**
920 : : * file_open_name - open file and return file pointer
921 : : *
922 : : * @name: struct filename containing path to open
923 : : * @flags: open flags as per the open(2) second argument
924 : : * @mode: mode for the new file if O_CREAT is set, else ignored
925 : : *
926 : : * This is the helper to open a file from kernelspace if you really
927 : : * have to. But in generally you should not do this, so please move
928 : : * along, nothing to see here..
929 : : */
930 : 0 : struct file *file_open_name(struct filename *name, int flags, umode_t mode)
931 : : {
932 : : struct open_flags op;
933 : : int err = build_open_flags(flags, mode, &op);
934 [ - + ]: 92 : return err ? ERR_PTR(err) : do_filp_open(AT_FDCWD, name, &op);
935 : : }
936 : :
937 : : /**
938 : : * filp_open - open file and return file pointer
939 : : *
940 : : * @filename: path to open
941 : : * @flags: open flags as per the open(2) second argument
942 : : * @mode: mode for the new file if O_CREAT is set, else ignored
943 : : *
944 : : * This is the helper to open a file from kernelspace if you really
945 : : * have to. But in generally you should not do this, so please move
946 : : * along, nothing to see here..
947 : : */
948 : 0 : struct file *filp_open(const char *filename, int flags, umode_t mode)
949 : : {
950 : 18 : struct filename name = {.name = filename};
951 : 18 : return file_open_name(&name, flags, mode);
952 : : }
953 : : EXPORT_SYMBOL(filp_open);
954 : :
955 : 0 : struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
956 : : const char *filename, int flags)
957 : : {
958 : : struct open_flags op;
959 : : int err = build_open_flags(flags, 0, &op);
960 [ # # ]: 0 : if (err)
961 : 0 : return ERR_PTR(err);
962 [ # # ]: 0 : if (flags & O_CREAT)
963 : : return ERR_PTR(-EINVAL);
964 [ # # ][ # # ]: 0 : if (!filename && (flags & O_DIRECTORY))
965 [ # # ]: 0 : if (!dentry->d_inode->i_op->lookup)
966 : : return ERR_PTR(-ENOTDIR);
967 : 0 : return do_file_open_root(dentry, mnt, filename, &op);
968 : : }
969 : : EXPORT_SYMBOL(file_open_root);
970 : :
971 : 0 : long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
972 : : {
973 : : struct open_flags op;
974 : : int fd = build_open_flags(flags, mode, &op);
975 : : struct filename *tmp;
976 : :
977 [ # # ]: 0 : if (fd)
978 : : return fd;
979 : :
980 : 5920967 : tmp = getname(filename);
981 [ + + ]: 5920890 : if (IS_ERR(tmp))
982 : 1 : return PTR_ERR(tmp);
983 : :
984 : 5920889 : fd = get_unused_fd_flags(flags);
985 [ + + ]: 5920934 : if (fd >= 0) {
986 : 5920926 : struct file *f = do_filp_open(dfd, tmp, &op);
987 [ + + ]: 5920964 : if (IS_ERR(f)) {
988 : 2530517 : put_unused_fd(fd);
989 : : fd = PTR_ERR(f);
990 : : } else {
991 : : fsnotify_open(f);
992 : 3390383 : fd_install(fd, f);
993 : : }
994 : : }
995 : 5920943 : putname(tmp);
996 : 5920944 : return fd;
997 : : }
998 : :
999 : 0 : SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1000 : : {
1001 : : if (force_o_largefile())
1002 : : flags |= O_LARGEFILE;
1003 : :
1004 : 5893704 : return do_sys_open(AT_FDCWD, filename, flags, mode);
1005 : : }
1006 : :
1007 : 0 : SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1008 : : umode_t, mode)
1009 : : {
1010 : : if (force_o_largefile())
1011 : : flags |= O_LARGEFILE;
1012 : :
1013 : 27248 : return do_sys_open(dfd, filename, flags, mode);
1014 : : }
1015 : :
1016 : : #ifndef __alpha__
1017 : :
1018 : : /*
1019 : : * For backward compatibility? Maybe this should be moved
1020 : : * into arch/i386 instead?
1021 : : */
1022 : 0 : SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1023 : : {
1024 : 271403 : return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1025 : : }
1026 : :
1027 : : #endif
1028 : :
1029 : : /*
1030 : : * "id" is the POSIX thread ID. We use the
1031 : : * files pointer for this..
1032 : : */
1033 : 0 : int filp_close(struct file *filp, fl_owner_t id)
1034 : : {
1035 : : int retval = 0;
1036 : :
1037 [ - + ]: 10901054 : if (!file_count(filp)) {
1038 : 0 : printk(KERN_ERR "VFS: Close: file count is 0\n");
1039 : 0 : return 0;
1040 : : }
1041 : :
1042 [ + + ]: 10901054 : if (filp->f_op->flush)
1043 : 35 : retval = filp->f_op->flush(filp, id);
1044 : :
1045 [ + - ]: 10900979 : if (likely(!(filp->f_mode & FMODE_PATH))) {
1046 : 10900979 : dnotify_flush(filp, id);
1047 : 10901106 : locks_remove_posix(filp, id);
1048 : : }
1049 : 10901055 : fput(filp);
1050 : 10901087 : return retval;
1051 : : }
1052 : :
1053 : : EXPORT_SYMBOL(filp_close);
1054 : :
1055 : : /*
1056 : : * Careful here! We test whether the file pointer is NULL before
1057 : : * releasing the fd. This ensures that one clone task can't release
1058 : : * an fd while another clone is opening it.
1059 : : */
1060 : 0 : SYSCALL_DEFINE1(close, unsigned int, fd)
1061 : : {
1062 : 4165376 : int retval = __close_fd(current->files, fd);
1063 : :
1064 : : /* can't restart close syscall because file table entry was cleared */
1065 [ + - ][ - + ]: 4165391 : if (unlikely(retval == -ERESTARTSYS ||
1066 : : retval == -ERESTARTNOINTR ||
1067 : : retval == -ERESTARTNOHAND ||
1068 : : retval == -ERESTART_RESTARTBLOCK))
1069 : : retval = -EINTR;
1070 : :
1071 : : return retval;
1072 : : }
1073 : : EXPORT_SYMBOL(sys_close);
1074 : :
1075 : : /*
1076 : : * This routine simulates a hangup on the tty, to arrange that users
1077 : : * are given clean terminals at login time.
1078 : : */
1079 : 0 : SYSCALL_DEFINE0(vhangup)
1080 : : {
1081 [ + + ]: 2 : if (capable(CAP_SYS_TTY_CONFIG)) {
1082 : 1 : tty_vhangup_self();
1083 : 1 : return 0;
1084 : : }
1085 : : return -EPERM;
1086 : : }
1087 : :
1088 : : /*
1089 : : * Called when an inode is about to be open.
1090 : : * We use this to disallow opening large files on 32bit systems if
1091 : : * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1092 : : * on this flag in sys_open.
1093 : : */
1094 : 0 : int generic_file_open(struct inode * inode, struct file * filp)
1095 : : {
1096 [ + + ][ + ]: 4051861 : if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1097 : : return -EOVERFLOW;
1098 : : return 0;
1099 : : }
1100 : :
1101 : : EXPORT_SYMBOL(generic_file_open);
1102 : :
1103 : : /*
1104 : : * This is used by subsystems that don't want seekable
1105 : : * file descriptors. The function is not supposed to ever fail, the only
1106 : : * reason it returns an 'int' and not 'void' is so that it can be plugged
1107 : : * directly into file_operations structure.
1108 : : */
1109 : 0 : int nonseekable_open(struct inode *inode, struct file *filp)
1110 : : {
1111 : 2133 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1112 : 2133 : return 0;
1113 : : }
1114 : :
1115 : : EXPORT_SYMBOL(nonseekable_open);
|
