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 [ + ]: 37631 : if (length < 0)
45 : : return -EINVAL;
46 : :
47 : 37632 : newattrs.ia_size = length;
48 : 37632 : newattrs.ia_valid = ATTR_SIZE | time_attrs;
49 [ + + ]: 37632 : if (filp) {
50 : 35951 : newattrs.ia_file = filp;
51 : 35951 : newattrs.ia_valid |= ATTR_FILE;
52 : : }
53 : :
54 : : /* Remove suid/sgid on truncate too */
55 : 37632 : ret = should_remove_suid(dentry);
56 [ - + ]: 37631 : if (ret)
57 : 0 : newattrs.ia_valid |= ret | ATTR_FORCE;
58 : :
59 : 37631 : mutex_lock(&dentry->d_inode->i_mutex);
60 : : /* Note any delegations or leases have already been broken: */
61 : 37636 : ret = notify_change(dentry, &newattrs, NULL);
62 : 37636 : mutex_unlock(&dentry->d_inode->i_mutex);
63 : 37636 : 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 : 1685 : inode = path->dentry->d_inode;
72 : :
73 : : /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
74 [ + ]: 1685 : if (S_ISDIR(inode->i_mode))
75 : : return -EISDIR;
76 [ + - ]: 1686 : if (!S_ISREG(inode->i_mode))
77 : : return -EINVAL;
78 : :
79 : 1686 : error = mnt_want_write(path->mnt);
80 [ + + ]: 1684 : if (error)
81 : : goto out;
82 : :
83 : 1681 : error = inode_permission(inode, MAY_WRITE);
84 [ + + ]: 1686 : if (error)
85 : : goto mnt_drop_write_and_out;
86 : :
87 : : error = -EPERM;
88 [ + + ]: 1684 : if (IS_APPEND(inode))
89 : : goto mnt_drop_write_and_out;
90 : :
91 : : error = get_write_access(inode);
92 [ + ]: 1676 : 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 [ + - ]: 1682 : if (!error)
105 : 1682 : error = security_path_truncate(path);
106 [ + - ]: 1680 : if (!error)
107 : 1680 : 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 : 1681 : mnt_drop_write(path->mnt);
113 : : out:
114 : 1686 : 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 [ + - ]: 1697 : if (length < 0) /* sorry, but loff_t says... */
125 : : return -EINVAL;
126 : :
127 : : retry:
128 : 1697 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
129 [ + + ]: 1697 : if (!error) {
130 : 1687 : error = vfs_truncate(&path, length);
131 : 1688 : path_put(&path);
132 : : }
133 [ - + ]: 1697 : 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 : 1677 : 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 [ + - ]: 32446 : if (length < 0)
161 : : goto out;
162 : : error = -EBADF;
163 : : f = fdget(fd);
164 [ + + ]: 32447 : if (!f.file)
165 : : goto out;
166 : :
167 : : /* explicitly opened as large or we are on 64-bit box */
168 [ + + ]: 32445 : if (f.file->f_flags & O_LARGEFILE)
169 : : small = 0;
170 : :
171 : 32445 : dentry = f.file->f_path.dentry;
172 : 32445 : inode = dentry->d_inode;
173 : : error = -EINVAL;
174 [ + + ][ + + ]: 32445 : 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 [ + ]: 32439 : if (small && length > MAX_NON_LFS)
180 : : goto out_putf;
181 : :
182 : : error = -EPERM;
183 [ + + ]: 32441 : if (IS_APPEND(inode))
184 : : goto out_putf;
185 : :
186 : 32439 : sb_start_write(inode->i_sb);
187 : : error = locks_verify_truncate(inode, f.file, length);
188 [ + + ]: 64887 : if (!error)
189 : 32421 : error = security_path_truncate(&f.file->f_path);
190 [ + + ]: 32440 : if (!error)
191 : 32420 : error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, f.file);
192 : 32441 : sb_end_write(inode->i_sb);
193 : : out_putf:
194 : : fdput(f);
195 : : out:
196 : 32447 : return error;
197 : : }
198 : :
199 : 0 : SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
200 : : {
201 : 32411 : 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 : 36 : 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 [ + + ]: 154636 : if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
310 : : return -EINVAL;
311 : :
312 : 154635 : override_cred = prepare_creds();
313 [ + + ]: 154633 : if (!override_cred)
314 : : return -ENOMEM;
315 : :
316 : 154632 : override_cred->fsuid = override_cred->uid;
317 : 154632 : override_cred->fsgid = override_cred->gid;
318 : :
319 [ + + ]: 154632 : 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 [ + + ]: 154631 : if (!uid_eq(override_cred->uid, root_uid))
323 : 1154 : cap_clear(override_cred->cap_effective);
324 : : else
325 : 153477 : override_cred->cap_effective =
326 : : override_cred->cap_permitted;
327 : : }
328 : :
329 : 154632 : old_cred = override_creds(override_cred);
330 : : retry:
331 : 154629 : res = user_path_at(dfd, filename, lookup_flags, &path);
332 [ + + ]: 154633 : if (res)
333 : : goto out;
334 : :
335 : 6180 : inode = path.dentry->d_inode;
336 : :
337 [ + + ][ + + ]: 6180 : 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 [ + - ]: 2905 : if (path.mnt->mnt_flags & MNT_NOEXEC)
344 : : goto out_path_release;
345 : : }
346 : :
347 : 6180 : res = inode_permission(inode, mode | MAY_ACCESS);
348 : : /* SuS v2 requires we report a read only fs too */
349 [ + + ][ + + ]: 6180 : 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 [ - + ]: 99 : if (__mnt_is_readonly(path.mnt))
362 : : res = -EROFS;
363 : :
364 : : out_path_release:
365 : 6180 : path_put(&path);
366 [ - + ]: 6180 : if (retry_estale(res, lookup_flags)) {
367 : : lookup_flags |= LOOKUP_REVAL;
368 : : goto retry;
369 : : }
370 : : out:
371 : 154633 : 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 : 154489 : return sys_faccessat(AT_FDCWD, filename, mode);
379 : : }
380 : :
381 : 7027 : 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 : 7027 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
388 [ + + ]: 7027 : if (error)
389 : : goto out;
390 : :
391 : 7007 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
392 [ + + ]: 7007 : if (error)
393 : : goto dput_and_out;
394 : :
395 : 7006 : set_fs_pwd(current->fs, &path);
396 : :
397 : : dput_and_out:
398 : 7007 : path_put(&path);
399 [ - + ]: 7007 : 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 [ + + ]: 507 : if (!f.file)
415 : : goto out;
416 : :
417 : : inode = file_inode(f.file);
418 : :
419 : : error = -ENOTDIR;
420 [ + - ]: 506 : if (!S_ISDIR(inode->i_mode))
421 : : goto out_putf;
422 : :
423 : 506 : error = inode_permission(inode, MAY_EXEC | MAY_CHDIR);
424 [ + + ]: 506 : if (!error)
425 : 505 : set_fs_pwd(current->fs, &f.file->f_path);
426 : : out_putf:
427 : : fdput(f);
428 : : out:
429 : : return error;
430 : : }
431 : :
432 : 8 : 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 : 8 : error = user_path_at(AT_FDCWD, filename, lookup_flags, &path);
439 [ + + ]: 8 : if (error)
440 : : goto out;
441 : :
442 : 3 : error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
443 [ + + ]: 3 : if (error)
444 : : goto dput_and_out;
445 : :
446 : : error = -EPERM;
447 [ + + ]: 2 : if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT))
448 : : goto dput_and_out;
449 : 1 : error = security_path_chroot(&path);
450 [ + - ]: 1 : if (error)
451 : : goto dput_and_out;
452 : :
453 : 1 : set_fs_root(current->fs, &path);
454 : : error = 0;
455 : : dput_and_out:
456 : 3 : path_put(&path);
457 [ - + ]: 3 : 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 : 3704 : struct inode *inode = path->dentry->d_inode;
468 : 3704 : struct inode *delegated_inode = NULL;
469 : : struct iattr newattrs;
470 : : int error;
471 : :
472 : 3704 : error = mnt_want_write(path->mnt);
473 [ + + ]: 3704 : if (error)
474 : : return error;
475 : : retry_deleg:
476 : 3702 : mutex_lock(&inode->i_mutex);
477 : 3702 : error = security_path_chmod(path, mode);
478 [ + - ]: 3702 : if (error)
479 : : goto out_unlock;
480 : 3702 : newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
481 : 3702 : newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
482 : 3702 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
483 : : out_unlock:
484 : 3702 : mutex_unlock(&inode->i_mutex);
485 [ - + ]: 3702 : if (delegated_inode) {
486 : : error = break_deleg_wait(&delegated_inode);
487 [ # # ]: 0 : if (!error)
488 : : goto retry_deleg;
489 : : }
490 : 3702 : mnt_drop_write(path->mnt);
491 : 3702 : 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 [ + + ]: 565 : if (f.file) {
500 : 564 : audit_inode(NULL, f.file->f_path.dentry, 0);
501 : 564 : err = chmod_common(&f.file->f_path, mode);
502 : : fdput(f);
503 : : }
504 : : return err;
505 : : }
506 : :
507 : 3160 : 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 : 3160 : error = user_path_at(dfd, filename, lookup_flags, &path);
514 [ + + ]: 3160 : if (!error) {
515 : 3140 : error = chmod_common(&path, mode);
516 : 3140 : path_put(&path);
517 [ - ]: 3140 : 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 : 3047 : 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 : 1665 : struct inode *inode = path->dentry->d_inode;
533 : 1665 : 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 : 1665 : newattrs.ia_valid = ATTR_CTIME;
543 [ + + ]: 1665 : if (user != (uid_t) -1) {
544 [ + - ]: 895 : if (!uid_valid(uid))
545 : : return -EINVAL;
546 : 895 : newattrs.ia_valid |= ATTR_UID;
547 : 895 : newattrs.ia_uid = uid;
548 : : }
549 [ + + ]: 1665 : if (group != (gid_t) -1) {
550 [ + - ]: 1625 : if (!gid_valid(gid))
551 : : return -EINVAL;
552 : 1625 : newattrs.ia_valid |= ATTR_GID;
553 : 1625 : newattrs.ia_gid = gid;
554 : : }
555 [ + + ]: 1665 : if (!S_ISDIR(inode->i_mode))
556 : 1665 : newattrs.ia_valid |=
557 : : ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
558 : : retry_deleg:
559 : 1665 : mutex_lock(&inode->i_mutex);
560 : 1665 : error = security_path_chown(path, uid, gid);
561 [ + - ]: 1665 : if (!error)
562 : 1665 : error = notify_change(path->dentry, &newattrs, &delegated_inode);
563 : 1665 : mutex_unlock(&inode->i_mutex);
564 [ - + ]: 3330 : if (delegated_inode) {
565 : : error = break_deleg_wait(&delegated_inode);
566 [ # # ]: 0 : if (!error)
567 : : goto retry_deleg;
568 : : }
569 : 1665 : 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 [ + + ]: 1182 : if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH)) != 0)
580 : : goto out;
581 : :
582 : 1181 : lookup_flags = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
583 [ - + ]: 1181 : if (flag & AT_EMPTY_PATH)
584 : 1181 : lookup_flags |= LOOKUP_EMPTY;
585 : : retry:
586 : 1181 : error = user_path_at(dfd, filename, lookup_flags, &path);
587 [ + + ]: 1181 : if (error)
588 : : goto out;
589 : 1147 : error = mnt_want_write(path.mnt);
590 [ + + ]: 1147 : if (error)
591 : : goto out_release;
592 : 1145 : error = chown_common(&path, user, group);
593 : 1145 : mnt_drop_write(path.mnt);
594 : : out_release:
595 : 1147 : path_put(&path);
596 [ - + ]: 1147 : 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 : 1110 : 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 : 26 : 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 [ + + ]: 522 : if (!f.file)
621 : : goto out;
622 : :
623 : 520 : error = mnt_want_write_file(f.file);
624 [ + - ]: 520 : if (error)
625 : : goto out_fput;
626 : 520 : audit_inode(NULL, f.file->f_path.dentry, 0);
627 : 520 : error = chown_common(&f.file->f_path, user, group);
628 : 520 : 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 [ + ]: 1837012 : 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 [ + + ][ + + ]: 1837036 : if (!special_file(inode->i_mode)) {
[ + + ]
654 : : /*
655 : : * Balanced in __fput()
656 : : */
657 : 1480512 : error = __mnt_want_write(mnt);
658 [ - + ]: 1480518 : 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 [ - + ][ + + ]: 2463403 : 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 : 2463338 : 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 : 4927004 : f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
686 : 2463502 : FMODE_PREAD | FMODE_PWRITE;
687 : :
688 [ - + ]: 2463502 : if (unlikely(f->f_flags & O_PATH))
689 : 0 : f->f_mode = FMODE_PATH;
690 : :
691 : 2463502 : path_get(&f->f_path);
692 : 2463610 : inode = f->f_inode = f->f_path.dentry->d_inode;
693 [ + + ]: 2463610 : if (f->f_mode & FMODE_WRITE) {
694 : 1836914 : error = __get_file_write_access(inode, f->f_path.mnt);
695 [ + + ]: 1836745 : if (error)
696 : : goto cleanup_file;
697 : : if (!special_file(inode->i_mode))
698 : : file_take_write(f);
699 : : }
700 : :
701 : 2463440 : f->f_mapping = inode->i_mapping;
702 : :
703 [ - + ]: 2463440 : if (unlikely(f->f_mode & FMODE_PATH)) {
704 : 0 : f->f_op = &empty_fops;
705 : 0 : return 0;
706 : : }
707 : :
708 : : /* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
709 [ + + ]: 2463440 : if (S_ISREG(inode->i_mode))
710 : 2070573 : f->f_mode |= FMODE_ATOMIC_POS;
711 : :
712 [ + ][ + + ]: 2463440 : f->f_op = fops_get(inode->i_fop);
713 [ - + ][ + + ]: 2463365 : if (unlikely(WARN_ON(!f->f_op))) {
714 : : error = -ENODEV;
715 : : goto cleanup_all;
716 : : }
717 : :
718 : 2463643 : error = security_file_open(f, cred);
719 [ + ]: 2463609 : if (error)
720 : : goto cleanup_all;
721 : :
722 : 2463610 : error = break_lease(inode, f->f_flags);
723 [ + - ]: 2463623 : if (error)
724 : : goto cleanup_all;
725 : :
726 [ + + ]: 2463623 : if (!open)
727 : 2463464 : open = f->f_op->open;
728 [ + + ]: 2463623 : if (open) {
729 : 2427341 : error = open(inode, f);
730 [ + + ]: 2427284 : if (error)
731 : : goto cleanup_all;
732 : : }
733 : : if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
734 : : i_readcount_inc(inode);
735 : :
736 : 2463540 : f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
737 : :
738 : 2463540 : file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
739 : :
740 : 2463481 : return 0;
741 : :
742 : : cleanup_all:
743 [ + - ]: 40 : fops_put(f->f_op);
744 [ + - ]: 40 : if (f->f_mode & FMODE_WRITE) {
745 : : put_write_access(inode);
746 [ + + ][ - + ]: 40 : if (!special_file(inode->i_mode)) {
[ # # ]
747 : : /*
748 : : * We don't consider this a real
749 : : * mnt_want/drop_write() pair
750 : : * because it all happenend right
751 : : * here, so just reset the state.
752 : : */
753 : : file_reset_write(f);
754 : 0 : __mnt_drop_write(f->f_path.mnt);
755 : : }
756 : : }
757 : : cleanup_file:
758 : 41 : path_put(&f->f_path);
759 : 41 : f->f_path.mnt = NULL;
760 : 41 : f->f_path.dentry = NULL;
761 : 41 : f->f_inode = NULL;
762 : 41 : return error;
763 : : }
764 : :
765 : : /**
766 : : * finish_open - finish opening a file
767 : : * @file: file pointer
768 : : * @dentry: pointer to dentry
769 : : * @open: open callback
770 : : * @opened: state of open
771 : : *
772 : : * This can be used to finish opening a file passed to i_op->atomic_open().
773 : : *
774 : : * If the open callback is set to NULL, then the standard f_op->open()
775 : : * filesystem callback is substituted.
776 : : *
777 : : * NB: the dentry reference is _not_ consumed. If, for example, the dentry is
778 : : * the return value of d_splice_alias(), then the caller needs to perform dput()
779 : : * on it after finish_open().
780 : : *
781 : : * On successful return @file is a fully instantiated open file. After this, if
782 : : * an error occurs in ->atomic_open(), it needs to clean up with fput().
783 : : *
784 : : * Returns zero on success or -errno if the open failed.
785 : : */
786 : 0 : int finish_open(struct file *file, struct dentry *dentry,
787 : : int (*open)(struct inode *, struct file *),
788 : : int *opened)
789 : : {
790 : : int error;
791 [ - + ]: 2463477 : BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
792 : :
793 : 2463477 : file->f_path.dentry = dentry;
794 : 2463477 : error = do_dentry_open(file, open, current_cred());
795 [ + + ]: 2463509 : if (!error)
796 : 2463444 : *opened |= FILE_OPENED;
797 : :
798 : 32 : return error;
799 : : }
800 : : EXPORT_SYMBOL(finish_open);
801 : :
802 : : /**
803 : : * finish_no_open - finish ->atomic_open() without opening the file
804 : : *
805 : : * @file: file pointer
806 : : * @dentry: dentry or NULL (as returned from ->lookup())
807 : : *
808 : : * This can be used to set the result of a successful lookup in ->atomic_open().
809 : : *
810 : : * NB: unlike finish_open() this function does consume the dentry reference and
811 : : * the caller need not dput() it.
812 : : *
813 : : * Returns "1" which must be the return value of ->atomic_open() after having
814 : : * called this function.
815 : : */
816 : 0 : int finish_no_open(struct file *file, struct dentry *dentry)
817 : : {
818 : 0 : file->f_path.dentry = dentry;
819 : 0 : return 1;
820 : : }
821 : : EXPORT_SYMBOL(finish_no_open);
822 : :
823 : 0 : struct file *dentry_open(const struct path *path, int flags,
824 : : const struct cred *cred)
825 : : {
826 : : int error;
827 : : struct file *f;
828 : :
829 : : validate_creds(cred);
830 : :
831 : : /* We must always pass in a valid mount pointer. */
832 [ - + ]: 33 : BUG_ON(!path->mnt);
833 : :
834 : 33 : f = get_empty_filp();
835 [ + - ]: 33 : if (!IS_ERR(f)) {
836 : 33 : f->f_flags = flags;
837 : 33 : f->f_path = *path;
838 : 33 : error = do_dentry_open(f, NULL, cred);
839 [ + - ]: 33 : if (!error) {
840 : : /* from now on we need fput() to dispose of f */
841 : : error = open_check_o_direct(f);
842 [ - + ]: 33 : if (error) {
843 : 0 : fput(f);
844 : : f = ERR_PTR(error);
845 : : }
846 : : } else {
847 : 0 : put_filp(f);
848 : : f = ERR_PTR(error);
849 : : }
850 : : }
851 : 0 : return f;
852 : : }
853 : : EXPORT_SYMBOL(dentry_open);
854 : :
855 : : static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
856 : : {
857 : : int lookup_flags = 0;
858 : : int acc_mode;
859 : :
860 [ + + ][ # # ]: 3017659 : if (flags & (O_CREAT | __O_TMPFILE))
[ + + ]
861 : 1803390 : op->mode = (mode & S_IALLUGO) | S_IFREG;
862 : : else
863 : 1214269 : op->mode = 0;
864 : :
865 : : /* Must never be set by userspace */
866 : 3017659 : flags &= ~FMODE_NONOTIFY & ~O_CLOEXEC;
867 : :
868 : : /*
869 : : * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
870 : : * check for O_DSYNC if the need any syncing at all we enforce it's
871 : : * always set instead of having to deal with possibly weird behaviour
872 : : * for malicious applications setting only __O_SYNC.
873 : : */
874 [ + + ][ # # ]: 3017659 : if (flags & __O_SYNC)
[ - + ]
875 : 59 : flags |= O_DSYNC;
876 : :
877 [ - + ][ # # ]: 3017659 : if (flags & __O_TMPFILE) {
[ - + ]
878 [ # # ][ # # ]: 0 : if ((flags & O_TMPFILE_MASK) != O_TMPFILE)
[ # # ]
879 : : return -EINVAL;
880 : 0 : acc_mode = MAY_OPEN | ACC_MODE(flags);
881 [ # # ][ # # ]: 0 : if (!(acc_mode & MAY_WRITE))
[ # # ]
882 : : return -EINVAL;
883 [ - + ][ # # ]: 3017659 : } else if (flags & O_PATH) {
[ - + ]
884 : : /*
885 : : * If we have O_PATH in the open flag. Then we
886 : : * cannot have anything other than the below set of flags
887 : : */
888 : 0 : flags &= O_DIRECTORY | O_NOFOLLOW | O_PATH;
889 : : acc_mode = 0;
890 : : } else {
891 : 3017659 : acc_mode = MAY_OPEN | ACC_MODE(flags);
892 : : }
893 : :
894 : 6035292 : op->open_flag = flags;
895 : :
896 : : /* O_TRUNC implies we need access checks for write permissions */
897 [ + + ][ # # ]: 6035292 : if (flags & O_TRUNC)
[ - + ]
898 : 192264 : acc_mode |= MAY_WRITE;
899 : :
900 : : /* Allow the LSM permission hook to distinguish append
901 : : access from general write access. */
902 [ + + ][ # # ]: 6035292 : if (flags & O_APPEND)
[ + + ]
903 : 3498 : acc_mode |= MAY_APPEND;
904 : :
905 : 3017731 : op->acc_mode = acc_mode;
906 : :
907 [ + ][ # # ]: 3017731 : op->intent = flags & O_PATH ? 0 : LOOKUP_OPEN;
[ + - ]
908 : :
909 [ + + ][ # # ]: 3017731 : if (flags & O_CREAT) {
[ + + ]
910 : 1803436 : op->intent |= LOOKUP_CREATE;
911 [ + + ][ # # ]: 1803436 : if (flags & O_EXCL)
[ - + ]
912 : 949 : op->intent |= LOOKUP_EXCL;
913 : : }
914 : :
915 [ + + ][ # # ]: 3017731 : if (flags & O_DIRECTORY)
[ - + ]
916 : : lookup_flags |= LOOKUP_DIRECTORY;
917 [ + + ][ # # ]: 3017731 : if (!(flags & O_NOFOLLOW))
[ + + ]
918 : 3008551 : lookup_flags |= LOOKUP_FOLLOW;
919 : 3017731 : op->lookup_flags = lookup_flags;
920 : : return 0;
921 : : }
922 : :
923 : : /**
924 : : * file_open_name - open file and return file pointer
925 : : *
926 : : * @name: struct filename containing path to open
927 : : * @flags: open flags as per the open(2) second argument
928 : : * @mode: mode for the new file if O_CREAT is set, else ignored
929 : : *
930 : : * This is the helper to open a file from kernelspace if you really
931 : : * have to. But in generally you should not do this, so please move
932 : : * along, nothing to see here..
933 : : */
934 : 0 : struct file *file_open_name(struct filename *name, int flags, umode_t mode)
935 : : {
936 : : struct open_flags op;
937 : : int err = build_open_flags(flags, mode, &op);
938 [ - + ]: 98 : return err ? ERR_PTR(err) : do_filp_open(AT_FDCWD, name, &op);
939 : : }
940 : :
941 : : /**
942 : : * filp_open - open file and return file pointer
943 : : *
944 : : * @filename: path to open
945 : : * @flags: open flags as per the open(2) second argument
946 : : * @mode: mode for the new file if O_CREAT is set, else ignored
947 : : *
948 : : * This is the helper to open a file from kernelspace if you really
949 : : * have to. But in generally you should not do this, so please move
950 : : * along, nothing to see here..
951 : : */
952 : 0 : struct file *filp_open(const char *filename, int flags, umode_t mode)
953 : : {
954 : 18 : struct filename name = {.name = filename};
955 : 18 : return file_open_name(&name, flags, mode);
956 : : }
957 : : EXPORT_SYMBOL(filp_open);
958 : :
959 : 0 : struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
960 : : const char *filename, int flags)
961 : : {
962 : : struct open_flags op;
963 : : int err = build_open_flags(flags, 0, &op);
964 [ # # ]: 0 : if (err)
965 : 0 : return ERR_PTR(err);
966 [ # # ]: 0 : if (flags & O_CREAT)
967 : : return ERR_PTR(-EINVAL);
968 [ # # ][ # # ]: 0 : if (!filename && (flags & O_DIRECTORY))
969 [ # # ]: 0 : if (!dentry->d_inode->i_op->lookup)
970 : : return ERR_PTR(-ENOTDIR);
971 : 0 : return do_file_open_root(dentry, mnt, filename, &op);
972 : : }
973 : : EXPORT_SYMBOL(file_open_root);
974 : :
975 : 0 : long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
976 : : {
977 : : struct open_flags op;
978 : : int fd = build_open_flags(flags, mode, &op);
979 : : struct filename *tmp;
980 : :
981 [ # # ]: 0 : if (fd)
982 : : return fd;
983 : :
984 : 3017713 : tmp = getname(filename);
985 [ + + ]: 3017691 : if (IS_ERR(tmp))
986 : 3 : return PTR_ERR(tmp);
987 : :
988 : 3017688 : fd = get_unused_fd_flags(flags);
989 [ + + ]: 3017792 : if (fd >= 0) {
990 : 3017613 : struct file *f = do_filp_open(dfd, tmp, &op);
991 [ + + ]: 3017704 : if (IS_ERR(f)) {
992 : 609135 : put_unused_fd(fd);
993 : : fd = PTR_ERR(f);
994 : : } else {
995 : : fsnotify_open(f);
996 : 2408617 : fd_install(fd, f);
997 : : }
998 : : }
999 : 3017974 : putname(tmp);
1000 : 3017558 : return fd;
1001 : : }
1002 : :
1003 : 0 : SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
1004 : : {
1005 : : if (force_o_largefile())
1006 : : flags |= O_LARGEFILE;
1007 : :
1008 : 3000480 : return do_sys_open(AT_FDCWD, filename, flags, mode);
1009 : : }
1010 : :
1011 : 0 : SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1012 : : umode_t, mode)
1013 : : {
1014 : : if (force_o_largefile())
1015 : : flags |= O_LARGEFILE;
1016 : :
1017 : 17241 : return do_sys_open(dfd, filename, flags, mode);
1018 : : }
1019 : :
1020 : : #ifndef __alpha__
1021 : :
1022 : : /*
1023 : : * For backward compatibility? Maybe this should be moved
1024 : : * into arch/i386 instead?
1025 : : */
1026 : 0 : SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
1027 : : {
1028 : 159620 : return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1029 : : }
1030 : :
1031 : : #endif
1032 : :
1033 : : /*
1034 : : * "id" is the POSIX thread ID. We use the
1035 : : * files pointer for this..
1036 : : */
1037 : 0 : int filp_close(struct file *filp, fl_owner_t id)
1038 : : {
1039 : : int retval = 0;
1040 : :
1041 [ - + ]: 9564839 : if (!file_count(filp)) {
1042 : 0 : printk(KERN_ERR "VFS: Close: file count is 0\n");
1043 : 0 : return 0;
1044 : : }
1045 : :
1046 [ + + ]: 9564839 : if (filp->f_op->flush)
1047 : 35 : retval = filp->f_op->flush(filp, id);
1048 : :
1049 [ + - ]: 9575287 : if (likely(!(filp->f_mode & FMODE_PATH))) {
1050 : 9575287 : dnotify_flush(filp, id);
1051 : 9570600 : locks_remove_posix(filp, id);
1052 : : }
1053 : 9571622 : fput(filp);
1054 : 9573582 : return retval;
1055 : : }
1056 : :
1057 : : EXPORT_SYMBOL(filp_close);
1058 : :
1059 : : /*
1060 : : * Careful here! We test whether the file pointer is NULL before
1061 : : * releasing the fd. This ensures that one clone task can't release
1062 : : * an fd while another clone is opening it.
1063 : : */
1064 : 0 : SYSCALL_DEFINE1(close, unsigned int, fd)
1065 : : {
1066 : 3057333 : int retval = __close_fd(current->files, fd);
1067 : :
1068 : : /* can't restart close syscall because file table entry was cleared */
1069 [ + ][ + + ]: 3069179 : if (unlikely(retval == -ERESTARTSYS ||
1070 : : retval == -ERESTARTNOINTR ||
1071 : : retval == -ERESTARTNOHAND ||
1072 : : retval == -ERESTART_RESTARTBLOCK))
1073 : : retval = -EINTR;
1074 : :
1075 : : return retval;
1076 : : }
1077 : : EXPORT_SYMBOL(sys_close);
1078 : :
1079 : : /*
1080 : : * This routine simulates a hangup on the tty, to arrange that users
1081 : : * are given clean terminals at login time.
1082 : : */
1083 : 0 : SYSCALL_DEFINE0(vhangup)
1084 : : {
1085 [ + + ]: 2 : if (capable(CAP_SYS_TTY_CONFIG)) {
1086 : 1 : tty_vhangup_self();
1087 : 1 : return 0;
1088 : : }
1089 : : return -EPERM;
1090 : : }
1091 : :
1092 : : /*
1093 : : * Called when an inode is about to be open.
1094 : : * We use this to disallow opening large files on 32bit systems if
1095 : : * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1096 : : * on this flag in sys_open.
1097 : : */
1098 : 0 : int generic_file_open(struct inode * inode, struct file * filp)
1099 : : {
1100 [ + + ][ + ]: 2596982 : if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1101 : : return -EOVERFLOW;
1102 : : return 0;
1103 : : }
1104 : :
1105 : : EXPORT_SYMBOL(generic_file_open);
1106 : :
1107 : : /*
1108 : : * This is used by subsystems that don't want seekable
1109 : : * file descriptors. The function is not supposed to ever fail, the only
1110 : : * reason it returns an 'int' and not 'void' is so that it can be plugged
1111 : : * directly into file_operations structure.
1112 : : */
1113 : 0 : int nonseekable_open(struct inode *inode, struct file *filp)
1114 : : {
1115 : 1273 : filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1116 : 1273 : return 0;
1117 : : }
1118 : :
1119 : : EXPORT_SYMBOL(nonseekable_open);
|
