~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/open.c

Version: ~ [ linux-6.0 ] ~ [ linux-5.19.12 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.71 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.146 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.215 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.260 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.295 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.330 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp