blob: 75b61677daafa9fdf0317ae58afd5d017ef03c2e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040010#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/quotaops.h>
Robert Love0eeca282005-07-12 17:06:03 -040012#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/module.h>
14#include <linux/slab.h>
15#include <linux/tty.h>
16#include <linux/namei.h>
17#include <linux/backing-dev.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080018#include <linux/capability.h>
Andrew G. Morgan086f7312008-07-04 09:59:58 -070019#include <linux/securebits.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/security.h>
21#include <linux/mount.h>
22#include <linux/vfs.h>
Ulrich Drepper5590ff02006-01-18 17:43:53 -080023#include <linux/fcntl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/uaccess.h>
25#include <linux/fs.h>
Yoav Zachef3daed2005-06-23 00:09:58 -070026#include <linux/personality.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/pagemap.h>
28#include <linux/syscalls.h>
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -070029#include <linux/rcupdate.h>
Amy Griffis73241cc2005-11-03 16:00:25 +000030#include <linux/audit.h>
Amit Arora97ac7352007-07-17 21:42:44 -040031#include <linux/falloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
David Howells726c3342006-06-23 02:02:58 -070033int vfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034{
35 int retval = -ENODEV;
36
David Howells726c3342006-06-23 02:02:58 -070037 if (dentry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 retval = -ENOSYS;
David Howells726c3342006-06-23 02:02:58 -070039 if (dentry->d_sb->s_op->statfs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 memset(buf, 0, sizeof(*buf));
David Howells726c3342006-06-23 02:02:58 -070041 retval = security_sb_statfs(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (retval)
43 return retval;
David Howells726c3342006-06-23 02:02:58 -070044 retval = dentry->d_sb->s_op->statfs(dentry, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 if (retval == 0 && buf->f_frsize == 0)
46 buf->f_frsize = buf->f_bsize;
47 }
48 }
49 return retval;
50}
51
52EXPORT_SYMBOL(vfs_statfs);
53
David Howells726c3342006-06-23 02:02:58 -070054static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055{
56 struct kstatfs st;
57 int retval;
58
David Howells726c3342006-06-23 02:02:58 -070059 retval = vfs_statfs(dentry, &st);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 if (retval)
61 return retval;
62
63 if (sizeof(*buf) == sizeof(st))
64 memcpy(buf, &st, sizeof(st));
65 else {
66 if (sizeof buf->f_blocks == 4) {
Jon Tollefsonf4a67cc2008-07-23 21:27:55 -070067 if ((st.f_blocks | st.f_bfree | st.f_bavail |
68 st.f_bsize | st.f_frsize) &
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 0xffffffff00000000ULL)
70 return -EOVERFLOW;
71 /*
72 * f_files and f_ffree may be -1; it's okay to stuff
73 * that into 32 bits
74 */
75 if (st.f_files != -1 &&
76 (st.f_files & 0xffffffff00000000ULL))
77 return -EOVERFLOW;
78 if (st.f_ffree != -1 &&
79 (st.f_ffree & 0xffffffff00000000ULL))
80 return -EOVERFLOW;
81 }
82
83 buf->f_type = st.f_type;
84 buf->f_bsize = st.f_bsize;
85 buf->f_blocks = st.f_blocks;
86 buf->f_bfree = st.f_bfree;
87 buf->f_bavail = st.f_bavail;
88 buf->f_files = st.f_files;
89 buf->f_ffree = st.f_ffree;
90 buf->f_fsid = st.f_fsid;
91 buf->f_namelen = st.f_namelen;
92 buf->f_frsize = st.f_frsize;
93 memset(buf->f_spare, 0, sizeof(buf->f_spare));
94 }
95 return 0;
96}
97
David Howells726c3342006-06-23 02:02:58 -070098static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
100 struct kstatfs st;
101 int retval;
102
David Howells726c3342006-06-23 02:02:58 -0700103 retval = vfs_statfs(dentry, &st);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 if (retval)
105 return retval;
106
107 if (sizeof(*buf) == sizeof(st))
108 memcpy(buf, &st, sizeof(st));
109 else {
110 buf->f_type = st.f_type;
111 buf->f_bsize = st.f_bsize;
112 buf->f_blocks = st.f_blocks;
113 buf->f_bfree = st.f_bfree;
114 buf->f_bavail = st.f_bavail;
115 buf->f_files = st.f_files;
116 buf->f_ffree = st.f_ffree;
117 buf->f_fsid = st.f_fsid;
118 buf->f_namelen = st.f_namelen;
119 buf->f_frsize = st.f_frsize;
120 memset(buf->f_spare, 0, sizeof(buf->f_spare));
121 }
122 return 0;
123}
124
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100125SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Al Viro2d8f3032008-07-22 09:59:21 -0400127 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 int error;
129
Al Viro2d8f3032008-07-22 09:59:21 -0400130 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 if (!error) {
132 struct statfs tmp;
Al Viro2d8f3032008-07-22 09:59:21 -0400133 error = vfs_statfs_native(path.dentry, &tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
135 error = -EFAULT;
Al Viro2d8f3032008-07-22 09:59:21 -0400136 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 }
138 return error;
139}
140
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100141SYSCALL_DEFINE3(statfs64, const char __user *, pathname, size_t, sz, struct statfs64 __user *, buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Al Viro2d8f3032008-07-22 09:59:21 -0400143 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 long error;
145
146 if (sz != sizeof(*buf))
147 return -EINVAL;
Al Viro2d8f3032008-07-22 09:59:21 -0400148 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 if (!error) {
150 struct statfs64 tmp;
Al Viro2d8f3032008-07-22 09:59:21 -0400151 error = vfs_statfs64(path.dentry, &tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
153 error = -EFAULT;
Al Viro2d8f3032008-07-22 09:59:21 -0400154 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 }
156 return error;
157}
158
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100159SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 struct file * file;
162 struct statfs tmp;
163 int error;
164
165 error = -EBADF;
166 file = fget(fd);
167 if (!file)
168 goto out;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800169 error = vfs_statfs_native(file->f_path.dentry, &tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
171 error = -EFAULT;
172 fput(file);
173out:
174 return error;
175}
176
Heiko Carstens257ac262009-01-14 14:14:13 +0100177SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 struct file * file;
180 struct statfs64 tmp;
181 int error;
182
183 if (sz != sizeof(*buf))
184 return -EINVAL;
185
186 error = -EBADF;
187 file = fget(fd);
188 if (!file)
189 goto out;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800190 error = vfs_statfs64(file->f_path.dentry, &tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
192 error = -EFAULT;
193 fput(file);
194out:
195 return error;
196}
197
NeilBrown4a301312006-01-08 01:02:39 -0800198int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
199 struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 int err;
202 struct iattr newattrs;
203
204 /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
205 if (length < 0)
206 return -EINVAL;
207
208 newattrs.ia_size = length;
NeilBrown4a301312006-01-08 01:02:39 -0800209 newattrs.ia_valid = ATTR_SIZE | time_attrs;
Miklos Szeredicc4e69d2005-11-07 00:59:49 -0800210 if (filp) {
211 newattrs.ia_file = filp;
212 newattrs.ia_valid |= ATTR_FILE;
213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Linus Torvalds7b82dc02007-05-08 20:10:00 -0700215 /* Remove suid/sgid on truncate too */
216 newattrs.ia_valid |= should_remove_suid(dentry);
217
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800218 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 err = notify_change(dentry, &newattrs);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800220 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 return err;
222}
223
Al Viro2d8f3032008-07-22 09:59:21 -0400224static long do_sys_truncate(const char __user *pathname, loff_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
Al Viro2d8f3032008-07-22 09:59:21 -0400226 struct path path;
227 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 int error;
229
230 error = -EINVAL;
231 if (length < 0) /* sorry, but loff_t says... */
232 goto out;
233
Al Viro2d8f3032008-07-22 09:59:21 -0400234 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (error)
236 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400237 inode = path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239 /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
240 error = -EISDIR;
241 if (S_ISDIR(inode->i_mode))
242 goto dput_and_out;
243
244 error = -EINVAL;
245 if (!S_ISREG(inode->i_mode))
246 goto dput_and_out;
247
Al Viro2d8f3032008-07-22 09:59:21 -0400248 error = mnt_want_write(path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 if (error)
250 goto dput_and_out;
251
Al Viro256984a2008-07-22 08:09:30 -0400252 error = inode_permission(inode, MAY_WRITE);
Dave Hansen9ac9b842008-02-15 14:37:52 -0800253 if (error)
254 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 error = -EPERM;
Miklos Szeredic82e42d2008-06-24 16:50:12 +0200257 if (IS_APPEND(inode))
Dave Hansen9ac9b842008-02-15 14:37:52 -0800258 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 error = get_write_access(inode);
261 if (error)
Dave Hansen9ac9b842008-02-15 14:37:52 -0800262 goto mnt_drop_write_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
david m. richter97003822007-07-31 00:39:12 -0700264 /*
265 * Make sure that there are no leases. get_write_access() protects
266 * against the truncate racing with a lease-granting setlease().
267 */
268 error = break_lease(inode, FMODE_WRITE);
269 if (error)
270 goto put_write_and_out;
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 error = locks_verify_truncate(inode, NULL, length);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +0900273 if (!error)
274 error = security_path_truncate(&path, length, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 if (!error) {
Jan Kara9e3509e2009-01-26 16:45:12 +0100276 vfs_dq_init(inode);
Al Viro2d8f3032008-07-22 09:59:21 -0400277 error = do_truncate(path.dentry, length, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
david m. richter97003822007-07-31 00:39:12 -0700280put_write_and_out:
281 put_write_access(inode);
Dave Hansen9ac9b842008-02-15 14:37:52 -0800282mnt_drop_write_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400283 mnt_drop_write(path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400285 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286out:
287 return error;
288}
289
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100290SYSCALL_DEFINE2(truncate, const char __user *, path, unsigned long, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
292 /* on 32-bit boxen it will cut the range 2^31--2^32-1 off */
293 return do_sys_truncate(path, (long)length);
294}
295
Matt Mackallb01ec0e2006-01-08 01:05:20 -0800296static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
298 struct inode * inode;
299 struct dentry *dentry;
300 struct file * file;
301 int error;
302
303 error = -EINVAL;
304 if (length < 0)
305 goto out;
306 error = -EBADF;
307 file = fget(fd);
308 if (!file)
309 goto out;
310
311 /* explicitly opened as large or we are on 64-bit box */
312 if (file->f_flags & O_LARGEFILE)
313 small = 0;
314
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800315 dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 inode = dentry->d_inode;
317 error = -EINVAL;
318 if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
319 goto out_putf;
320
321 error = -EINVAL;
322 /* Cannot ftruncate over 2^31 bytes without large file support */
323 if (small && length > MAX_NON_LFS)
324 goto out_putf;
325
326 error = -EPERM;
327 if (IS_APPEND(inode))
328 goto out_putf;
329
330 error = locks_verify_truncate(inode, file, length);
331 if (!error)
Kentaro Takedabe6d3e52008-12-17 13:24:15 +0900332 error = security_path_truncate(&file->f_path, length,
333 ATTR_MTIME|ATTR_CTIME);
334 if (!error)
Peter Staubach6e656be2006-06-25 05:48:36 -0700335 error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336out_putf:
337 fput(file);
338out:
339 return error;
340}
341
Heiko Carstensbdc480e2009-01-14 14:14:12 +0100342SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Linus Torvalds0a489cb2006-04-18 13:02:48 -0700344 long ret = do_sys_ftruncate(fd, length, 1);
Linus Torvalds385910f2006-04-18 13:22:59 -0700345 /* avoid REGPARM breakage on x86: */
Roland McGrath54a01512008-04-10 15:37:38 -0700346 asmlinkage_protect(2, ret, fd, length);
Linus Torvalds0a489cb2006-04-18 13:02:48 -0700347 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
350/* LFS versions of truncate are only needed on 32 bit machines */
351#if BITS_PER_LONG == 32
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100352SYSCALL_DEFINE(truncate64)(const char __user * path, loff_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
354 return do_sys_truncate(path, length);
355}
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100356#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
357asmlinkage long SyS_truncate64(long path, loff_t length)
358{
359 return SYSC_truncate64((const char __user *) path, length);
360}
361SYSCALL_ALIAS(sys_truncate64, SyS_truncate64);
362#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100364SYSCALL_DEFINE(ftruncate64)(unsigned int fd, loff_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Linus Torvalds0a489cb2006-04-18 13:02:48 -0700366 long ret = do_sys_ftruncate(fd, length, 0);
Linus Torvalds385910f2006-04-18 13:22:59 -0700367 /* avoid REGPARM breakage on x86: */
Roland McGrath54a01512008-04-10 15:37:38 -0700368 asmlinkage_protect(2, ret, fd, length);
Linus Torvalds0a489cb2006-04-18 13:02:48 -0700369 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370}
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100371#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
372asmlinkage long SyS_ftruncate64(long fd, loff_t length)
373{
374 return SYSC_ftruncate64((unsigned int) fd, length);
375}
376SYSCALL_ALIAS(sys_ftruncate64, SyS_ftruncate64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377#endif
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100378#endif /* BITS_PER_LONG == 32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100380SYSCALL_DEFINE(fallocate)(int fd, int mode, loff_t offset, loff_t len)
Amit Arora97ac7352007-07-17 21:42:44 -0400381{
382 struct file *file;
383 struct inode *inode;
384 long ret = -EINVAL;
385
386 if (offset < 0 || len <= 0)
387 goto out;
388
389 /* Return error if mode is not supported */
390 ret = -EOPNOTSUPP;
391 if (mode && !(mode & FALLOC_FL_KEEP_SIZE))
392 goto out;
393
394 ret = -EBADF;
395 file = fget(fd);
396 if (!file)
397 goto out;
398 if (!(file->f_mode & FMODE_WRITE))
399 goto out_fput;
400 /*
401 * Revalidate the write permissions, in case security policy has
402 * changed since the files were opened.
403 */
404 ret = security_file_permission(file, MAY_WRITE);
405 if (ret)
406 goto out_fput;
407
408 inode = file->f_path.dentry->d_inode;
409
410 ret = -ESPIPE;
411 if (S_ISFIFO(inode->i_mode))
412 goto out_fput;
413
414 ret = -ENODEV;
415 /*
416 * Let individual file system decide if it supports preallocation
417 * for directories or not.
418 */
419 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
420 goto out_fput;
421
422 ret = -EFBIG;
423 /* Check for wrap through zero too */
424 if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
425 goto out_fput;
426
Al Viroacfa4382008-12-04 10:06:33 -0500427 if (inode->i_op->fallocate)
Amit Arora97ac7352007-07-17 21:42:44 -0400428 ret = inode->i_op->fallocate(inode, mode, offset, len);
429 else
Ulrich Drepper0d786d42007-07-23 18:43:46 -0700430 ret = -EOPNOTSUPP;
Amit Arora97ac7352007-07-17 21:42:44 -0400431
432out_fput:
433 fput(file);
434out:
435 return ret;
436}
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100437#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
438asmlinkage long SyS_fallocate(long fd, long mode, loff_t offset, loff_t len)
439{
440 return SYSC_fallocate((int)fd, (int)mode, offset, len);
441}
442SYSCALL_ALIAS(sys_fallocate, SyS_fallocate);
443#endif
Amit Arora97ac7352007-07-17 21:42:44 -0400444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445/*
446 * access() needs to use the real uid/gid, not the effective uid/gid.
447 * We do this by temporarily clearing all FS-related capabilities and
448 * switching the fsuid/fsgid around to the real ones.
449 */
Heiko Carstens6559eed82009-01-14 14:14:32 +0100450SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
David Howellsd84f4f92008-11-14 10:39:23 +1100452 const struct cred *old_cred;
453 struct cred *override_cred;
Al Viro2d8f3032008-07-22 09:59:21 -0400454 struct path path;
Al Viro256984a2008-07-22 08:09:30 -0400455 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 int res;
457
458 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
459 return -EINVAL;
460
David Howellsd84f4f92008-11-14 10:39:23 +1100461 override_cred = prepare_creds();
462 if (!override_cred)
463 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
David Howellsd84f4f92008-11-14 10:39:23 +1100465 override_cred->fsuid = override_cred->uid;
466 override_cred->fsgid = override_cred->gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700468 if (!issecure(SECURE_NO_SETUID_FIXUP)) {
David Howells1cdcbec2008-11-14 10:39:14 +1100469 /* Clear the capabilities if we switch to a non-root user */
David Howellsd84f4f92008-11-14 10:39:23 +1100470 if (override_cred->uid)
471 cap_clear(override_cred->cap_effective);
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700472 else
David Howellsd84f4f92008-11-14 10:39:23 +1100473 override_cred->cap_effective =
474 override_cred->cap_permitted;
Andrew G. Morgan086f7312008-07-04 09:59:58 -0700475 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
David Howellsd84f4f92008-11-14 10:39:23 +1100477 old_cred = override_creds(override_cred);
478
Al Viro2d8f3032008-07-22 09:59:21 -0400479 res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700480 if (res)
481 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Al Viro2d8f3032008-07-22 09:59:21 -0400483 inode = path.dentry->d_inode;
Al Viro256984a2008-07-22 08:09:30 -0400484
485 if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
Al Viro30524472008-07-22 00:02:33 -0400486 /*
487 * MAY_EXEC on regular files is denied if the fs is mounted
488 * with the "noexec" flag.
489 */
490 res = -EACCES;
Al Viro2d8f3032008-07-22 09:59:21 -0400491 if (path.mnt->mnt_flags & MNT_NOEXEC)
Al Viro30524472008-07-22 00:02:33 -0400492 goto out_path_release;
493 }
494
Al Viro256984a2008-07-22 08:09:30 -0400495 res = inode_permission(inode, mode | MAY_ACCESS);
Dave Hansen6902d922006-09-30 23:29:01 -0700496 /* SuS v2 requires we report a read only fs too */
Al Viro256984a2008-07-22 08:09:30 -0400497 if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
Dave Hansen6902d922006-09-30 23:29:01 -0700498 goto out_path_release;
Dave Hansen2f676cb2008-02-15 14:37:55 -0800499 /*
500 * This is a rare case where using __mnt_is_readonly()
501 * is OK without a mnt_want/drop_write() pair. Since
502 * no actual write to the fs is performed here, we do
503 * not need to telegraph to that to anyone.
504 *
505 * By doing this, we accept that this access is
506 * inherently racy and know that the fs may change
507 * state before we even see this result.
508 */
Al Viro2d8f3032008-07-22 09:59:21 -0400509 if (__mnt_is_readonly(path.mnt))
Dave Hansen6902d922006-09-30 23:29:01 -0700510 res = -EROFS;
511
512out_path_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400513 path_put(&path);
Dave Hansen6902d922006-09-30 23:29:01 -0700514out:
David Howellsd84f4f92008-11-14 10:39:23 +1100515 revert_creds(old_cred);
516 put_cred(override_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 return res;
518}
519
Heiko Carstensca013e92009-01-14 14:14:19 +0100520SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800521{
522 return sys_faccessat(AT_FDCWD, filename, mode);
523}
524
Heiko Carstens3cdad422009-01-14 14:14:22 +0100525SYSCALL_DEFINE1(chdir, const char __user *, filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Al Viro2d8f3032008-07-22 09:59:21 -0400527 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 int error;
529
Al Viro2d8f3032008-07-22 09:59:21 -0400530 error = user_path_dir(filename, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if (error)
532 goto out;
533
Al Viro2d8f3032008-07-22 09:59:21 -0400534 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (error)
536 goto dput_and_out;
537
Al Viro2d8f3032008-07-22 09:59:21 -0400538 set_fs_pwd(current->fs, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400541 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542out:
543 return error;
544}
545
Heiko Carstens3cdad422009-01-14 14:14:22 +0100546SYSCALL_DEFINE1(fchdir, unsigned int, fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
548 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 int error;
551
552 error = -EBADF;
553 file = fget(fd);
554 if (!file)
555 goto out;
556
Jan Blunckac748a02008-02-14 19:34:39 -0800557 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 error = -ENOTDIR;
560 if (!S_ISDIR(inode->i_mode))
561 goto out_putf;
562
Al Viro256984a2008-07-22 08:09:30 -0400563 error = inode_permission(inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 if (!error)
Jan Blunckac748a02008-02-14 19:34:39 -0800565 set_fs_pwd(current->fs, &file->f_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566out_putf:
567 fput(file);
568out:
569 return error;
570}
571
Heiko Carstens3480b252009-01-14 14:14:16 +0100572SYSCALL_DEFINE1(chroot, const char __user *, filename)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573{
Al Viro2d8f3032008-07-22 09:59:21 -0400574 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 int error;
576
Al Viro2d8f3032008-07-22 09:59:21 -0400577 error = user_path_dir(filename, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (error)
579 goto out;
580
Al Viro2d8f3032008-07-22 09:59:21 -0400581 error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 if (error)
583 goto dput_and_out;
584
585 error = -EPERM;
586 if (!capable(CAP_SYS_CHROOT))
587 goto dput_and_out;
588
Al Viro2d8f3032008-07-22 09:59:21 -0400589 set_fs_root(current->fs, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 error = 0;
591dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400592 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593out:
594 return error;
595}
596
Heiko Carstensa26eab22009-01-14 14:14:17 +0100597SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
599 struct inode * inode;
600 struct dentry * dentry;
601 struct file * file;
602 int err = -EBADF;
603 struct iattr newattrs;
604
605 file = fget(fd);
606 if (!file)
607 goto out;
608
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800609 dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 inode = dentry->d_inode;
611
Al Viro5a190ae2007-06-07 12:19:32 -0400612 audit_inode(NULL, dentry);
Amy Griffis73241cc2005-11-03 16:00:25 +0000613
Dave Hansen2af482a2008-02-15 14:37:50 -0800614 err = mnt_want_write(file->f_path.mnt);
615 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 goto out_putf;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800617 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 if (mode == (mode_t) -1)
619 mode = inode->i_mode;
620 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
621 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
622 err = notify_change(dentry, &newattrs);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800623 mutex_unlock(&inode->i_mutex);
Dave Hansen2af482a2008-02-15 14:37:50 -0800624 mnt_drop_write(file->f_path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625out_putf:
626 fput(file);
627out:
628 return err;
629}
630
Heiko Carstens6559eed82009-01-14 14:14:32 +0100631SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
Al Viro2d8f3032008-07-22 09:59:21 -0400633 struct path path;
634 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 int error;
636 struct iattr newattrs;
637
Al Viro2d8f3032008-07-22 09:59:21 -0400638 error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 if (error)
640 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400641 inode = path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Al Viro2d8f3032008-07-22 09:59:21 -0400643 error = mnt_want_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800644 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 goto dput_and_out;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800646 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (mode == (mode_t) -1)
648 mode = inode->i_mode;
649 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
650 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
Al Viro2d8f3032008-07-22 09:59:21 -0400651 error = notify_change(path.dentry, &newattrs);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800652 mutex_unlock(&inode->i_mutex);
Al Viro2d8f3032008-07-22 09:59:21 -0400653 mnt_drop_write(path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654dput_and_out:
Al Viro2d8f3032008-07-22 09:59:21 -0400655 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656out:
657 return error;
658}
659
Heiko Carstensa26eab22009-01-14 14:14:17 +0100660SYSCALL_DEFINE2(chmod, const char __user *, filename, mode_t, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800661{
662 return sys_fchmodat(AT_FDCWD, filename, mode);
663}
664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
666{
Miklos Szeredibeb29e02008-07-01 15:01:29 +0200667 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 int error;
669 struct iattr newattrs;
670
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 newattrs.ia_valid = ATTR_CTIME;
672 if (user != (uid_t) -1) {
673 newattrs.ia_valid |= ATTR_UID;
674 newattrs.ia_uid = user;
675 }
676 if (group != (gid_t) -1) {
677 newattrs.ia_valid |= ATTR_GID;
678 newattrs.ia_gid = group;
679 }
680 if (!S_ISDIR(inode->i_mode))
Serge E. Hallynb5376772007-10-16 23:31:36 -0700681 newattrs.ia_valid |=
682 ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800683 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 error = notify_change(dentry, &newattrs);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800685 mutex_unlock(&inode->i_mutex);
Miklos Szeredibeb29e02008-07-01 15:01:29 +0200686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 return error;
688}
689
Heiko Carstensca013e92009-01-14 14:14:19 +0100690SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Al Viro2d8f3032008-07-22 09:59:21 -0400692 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 int error;
694
Al Viro2d8f3032008-07-22 09:59:21 -0400695 error = user_path(filename, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700696 if (error)
697 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400698 error = mnt_want_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800699 if (error)
700 goto out_release;
Al Viro2d8f3032008-07-22 09:59:21 -0400701 error = chown_common(path.dentry, user, group);
702 mnt_drop_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800703out_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400704 path_put(&path);
Dave Hansen6902d922006-09-30 23:29:01 -0700705out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return error;
707}
708
Heiko Carstens6559eed82009-01-14 14:14:32 +0100709SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
710 gid_t, group, int, flag)
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800711{
Al Viro2d8f3032008-07-22 09:59:21 -0400712 struct path path;
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800713 int error = -EINVAL;
714 int follow;
715
716 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
717 goto out;
718
719 follow = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
Al Viro2d8f3032008-07-22 09:59:21 -0400720 error = user_path_at(dfd, filename, follow, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700721 if (error)
722 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400723 error = mnt_want_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800724 if (error)
725 goto out_release;
Al Viro2d8f3032008-07-22 09:59:21 -0400726 error = chown_common(path.dentry, user, group);
727 mnt_drop_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800728out_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400729 path_put(&path);
Ulrich Drepper5590ff02006-01-18 17:43:53 -0800730out:
731 return error;
732}
733
Heiko Carstensca013e92009-01-14 14:14:19 +0100734SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735{
Al Viro2d8f3032008-07-22 09:59:21 -0400736 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 int error;
738
Al Viro2d8f3032008-07-22 09:59:21 -0400739 error = user_lpath(filename, &path);
Dave Hansen6902d922006-09-30 23:29:01 -0700740 if (error)
741 goto out;
Al Viro2d8f3032008-07-22 09:59:21 -0400742 error = mnt_want_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800743 if (error)
744 goto out_release;
Al Viro2d8f3032008-07-22 09:59:21 -0400745 error = chown_common(path.dentry, user, group);
746 mnt_drop_write(path.mnt);
Dave Hansen2af482a2008-02-15 14:37:50 -0800747out_release:
Al Viro2d8f3032008-07-22 09:59:21 -0400748 path_put(&path);
Dave Hansen6902d922006-09-30 23:29:01 -0700749out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return error;
751}
752
Heiko Carstensca013e92009-01-14 14:14:19 +0100753SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
755 struct file * file;
756 int error = -EBADF;
Dave Hansen6902d922006-09-30 23:29:01 -0700757 struct dentry * dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 file = fget(fd);
Dave Hansen6902d922006-09-30 23:29:01 -0700760 if (!file)
761 goto out;
762
Dave Hansen2af482a2008-02-15 14:37:50 -0800763 error = mnt_want_write(file->f_path.mnt);
764 if (error)
765 goto out_fput;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800766 dentry = file->f_path.dentry;
Al Viro5a190ae2007-06-07 12:19:32 -0400767 audit_inode(NULL, dentry);
Dave Hansen6902d922006-09-30 23:29:01 -0700768 error = chown_common(dentry, user, group);
Dave Hansen2af482a2008-02-15 14:37:50 -0800769 mnt_drop_write(file->f_path.mnt);
770out_fput:
Dave Hansen6902d922006-09-30 23:29:01 -0700771 fput(file);
772out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 return error;
774}
775
Dave Hansen4a3fd212008-02-15 14:37:48 -0800776/*
777 * You have to be very careful that these write
778 * counts get cleaned up in error cases and
779 * upon __fput(). This should probably never
780 * be called outside of __dentry_open().
781 */
782static inline int __get_file_write_access(struct inode *inode,
783 struct vfsmount *mnt)
784{
785 int error;
786 error = get_write_access(inode);
787 if (error)
788 return error;
789 /*
790 * Do not take mount writer counts on
791 * special files since no writes to
792 * the mount itself will occur.
793 */
794 if (!special_file(inode->i_mode)) {
795 /*
796 * Balanced in __fput()
797 */
798 error = mnt_want_write(mnt);
799 if (error)
800 put_write_access(inode);
801 }
802 return error;
803}
804
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700805static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
Trond Myklebust834f2a42005-10-18 14:20:16 -0700806 int flags, struct file *f,
David Howells745ca242008-11-14 10:39:22 +1100807 int (*open)(struct inode *, struct file *),
808 const struct cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 struct inode *inode;
811 int error;
812
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 f->f_flags = flags;
Al Viroaeb5d722008-09-02 15:28:45 -0400814 f->f_mode = (__force fmode_t)((flags+1) & O_ACCMODE) | FMODE_LSEEK |
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700815 FMODE_PREAD | FMODE_PWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 inode = dentry->d_inode;
817 if (f->f_mode & FMODE_WRITE) {
Dave Hansen4a3fd212008-02-15 14:37:48 -0800818 error = __get_file_write_access(inode, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (error)
820 goto cleanup_file;
Dave Hansenad775f52008-02-15 14:38:01 -0800821 if (!special_file(inode->i_mode))
822 file_take_write(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
824
825 f->f_mapping = inode->i_mapping;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800826 f->f_path.dentry = dentry;
827 f->f_path.mnt = mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 f->f_pos = 0;
829 f->f_op = fops_get(inode->i_fop);
830 file_move(f, &inode->i_sb->s_files);
831
David Howells745ca242008-11-14 10:39:22 +1100832 error = security_dentry_open(f, cred);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900833 if (error)
834 goto cleanup_all;
835
Trond Myklebust834f2a42005-10-18 14:20:16 -0700836 if (!open && f->f_op)
837 open = f->f_op->open;
838 if (open) {
839 error = open(inode, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 if (error)
841 goto cleanup_all;
842 }
Trond Myklebust834f2a42005-10-18 14:20:16 -0700843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
845
846 file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
847
848 /* NB: we're sure to have correct a_ops only after f_op->open */
849 if (f->f_flags & O_DIRECT) {
Carsten Otteceffc072005-06-23 22:05:25 -0700850 if (!f->f_mapping->a_ops ||
851 ((!f->f_mapping->a_ops->direct_IO) &&
Nick Piggin70688e42008-04-28 02:13:02 -0700852 (!f->f_mapping->a_ops->get_xip_mem))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 fput(f);
854 f = ERR_PTR(-EINVAL);
855 }
856 }
857
858 return f;
859
860cleanup_all:
861 fops_put(f->f_op);
Dave Hansen4a3fd212008-02-15 14:37:48 -0800862 if (f->f_mode & FMODE_WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 put_write_access(inode);
Dave Hansenad775f52008-02-15 14:38:01 -0800864 if (!special_file(inode->i_mode)) {
865 /*
866 * We don't consider this a real
867 * mnt_want/drop_write() pair
868 * because it all happenend right
869 * here, so just reset the state.
870 */
871 file_reset_write(f);
Dave Hansen4a3fd212008-02-15 14:37:48 -0800872 mnt_drop_write(mnt);
Dave Hansenad775f52008-02-15 14:38:01 -0800873 }
Dave Hansen4a3fd212008-02-15 14:37:48 -0800874 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 file_kill(f);
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800876 f->f_path.dentry = NULL;
877 f->f_path.mnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878cleanup_file:
879 put_filp(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 dput(dentry);
881 mntput(mnt);
882 return ERR_PTR(error);
883}
884
Trond Myklebust834f2a42005-10-18 14:20:16 -0700885/**
886 * lookup_instantiate_filp - instantiates the open intent filp
887 * @nd: pointer to nameidata
888 * @dentry: pointer to dentry
889 * @open: open callback
890 *
891 * Helper for filesystems that want to use lookup open intents and pass back
892 * a fully instantiated struct file to the caller.
893 * This function is meant to be called from within a filesystem's
894 * lookup method.
Oleg Drokin9a56c212006-03-25 03:07:02 -0800895 * Beware of calling it for non-regular files! Those ->open methods might block
896 * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
897 * leading to a deadlock, as nobody can open that fifo anymore, because
898 * another process to open fifo will block on locked parent when doing lookup).
Trond Myklebust834f2a42005-10-18 14:20:16 -0700899 * Note that in case of error, nd->intent.open.file is destroyed, but the
900 * path information remains valid.
901 * If the open callback is set to NULL, then the standard f_op->open()
902 * filesystem callback is substituted.
903 */
904struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
905 int (*open)(struct inode *, struct file *))
906{
David Howells745ca242008-11-14 10:39:22 +1100907 const struct cred *cred = current_cred();
908
Trond Myklebust834f2a42005-10-18 14:20:16 -0700909 if (IS_ERR(nd->intent.open.file))
910 goto out;
911 if (IS_ERR(dentry))
912 goto out_err;
Jan Blunck4ac91372008-02-14 19:34:32 -0800913 nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt),
Trond Myklebust834f2a42005-10-18 14:20:16 -0700914 nd->intent.open.flags - 1,
915 nd->intent.open.file,
David Howells745ca242008-11-14 10:39:22 +1100916 open, cred);
Trond Myklebust834f2a42005-10-18 14:20:16 -0700917out:
918 return nd->intent.open.file;
919out_err:
920 release_open_intent(nd);
921 nd->intent.open.file = (struct file *)dentry;
922 goto out;
923}
924EXPORT_SYMBOL_GPL(lookup_instantiate_filp);
925
926/**
927 * nameidata_to_filp - convert a nameidata to an open filp.
928 * @nd: pointer to nameidata
929 * @flags: open flags
930 *
931 * Note that this function destroys the original nameidata
932 */
933struct file *nameidata_to_filp(struct nameidata *nd, int flags)
934{
David Howells745ca242008-11-14 10:39:22 +1100935 const struct cred *cred = current_cred();
Trond Myklebust834f2a42005-10-18 14:20:16 -0700936 struct file *filp;
937
938 /* Pick up the filp from the open intent */
939 filp = nd->intent.open.file;
940 /* Has the filesystem initialised the file for us? */
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800941 if (filp->f_path.dentry == NULL)
Jan Blunck4ac91372008-02-14 19:34:32 -0800942 filp = __dentry_open(nd->path.dentry, nd->path.mnt, flags, filp,
David Howells745ca242008-11-14 10:39:22 +1100943 NULL, cred);
Trond Myklebust834f2a42005-10-18 14:20:16 -0700944 else
Jan Blunck1d957f92008-02-14 19:34:35 -0800945 path_put(&nd->path);
Trond Myklebust834f2a42005-10-18 14:20:16 -0700946 return filp;
947}
948
Peter Staubach6fdcc212005-11-07 00:59:42 -0800949/*
950 * dentry_open() will have done dput(dentry) and mntput(mnt) if it returns an
951 * error.
952 */
David Howells745ca242008-11-14 10:39:22 +1100953struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
954 const struct cred *cred)
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700955{
956 int error;
957 struct file *f;
958
Christoph Hellwig322ee5b2008-02-15 14:37:24 -0800959 /*
960 * We must always pass in a valid mount pointer. Historically
961 * callers got away with not passing it, but we must enforce this at
962 * the earliest possible point now to avoid strange problems deep in the
963 * filesystem stack.
964 */
965 if (!mnt) {
966 printk(KERN_WARNING "%s called with NULL vfsmount\n", __func__);
967 dump_stack();
968 return ERR_PTR(-EINVAL);
969 }
970
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700971 error = -ENFILE;
972 f = get_empty_filp();
Peter Staubach6fdcc212005-11-07 00:59:42 -0800973 if (f == NULL) {
974 dput(dentry);
975 mntput(mnt);
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700976 return ERR_PTR(error);
Peter Staubach6fdcc212005-11-07 00:59:42 -0800977 }
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700978
David Howells745ca242008-11-14 10:39:22 +1100979 return __dentry_open(dentry, mnt, flags, f, NULL, cred);
Peter Staubacha1a5b3d2005-09-13 01:25:12 -0700980}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981EXPORT_SYMBOL(dentry_open);
982
Matt Mackallb01ec0e2006-01-08 01:05:20 -0800983static void __put_unused_fd(struct files_struct *files, unsigned int fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700985 struct fdtable *fdt = files_fdtable(files);
986 __FD_CLR(fd, fdt->open_fds);
Eric Dumazet0c9e63f2006-03-23 03:00:12 -0800987 if (fd < files->next_fd)
988 files->next_fd = fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
990
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -0800991void put_unused_fd(unsigned int fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992{
993 struct files_struct *files = current->files;
994 spin_lock(&files->file_lock);
995 __put_unused_fd(files, fd);
996 spin_unlock(&files->file_lock);
997}
998
999EXPORT_SYMBOL(put_unused_fd);
1000
1001/*
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001002 * Install a file pointer in the fd array.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 *
1004 * The VFS is full of places where we drop the files lock between
1005 * setting the open_fds bitmap and installing the file in the file
1006 * array. At any such point, we are vulnerable to a dup2() race
1007 * installing a file in the array before us. We need to detect this and
1008 * fput() the struct file we are about to overwrite in this case.
1009 *
1010 * It should never happen - if we allow dup2() do it, _really_ bad things
1011 * will follow.
1012 */
1013
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001014void fd_install(unsigned int fd, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015{
1016 struct files_struct *files = current->files;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001017 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 spin_lock(&files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001019 fdt = files_fdtable(files);
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -07001020 BUG_ON(fdt->fd[fd] != NULL);
1021 rcu_assign_pointer(fdt->fd[fd], file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 spin_unlock(&files->file_lock);
1023}
1024
1025EXPORT_SYMBOL(fd_install);
1026
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001027long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028{
Miklos Szeredie922efc2005-09-06 15:18:25 -07001029 char *tmp = getname(filename);
1030 int fd = PTR_ERR(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (!IS_ERR(tmp)) {
Ulrich Drepperf23513e2007-07-15 23:40:32 -07001033 fd = get_unused_fd_flags(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 if (fd >= 0) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001035 struct file *f = do_filp_open(dfd, tmp, flags, mode);
Telemaque Ndizihiwefed2fc12005-06-23 00:10:33 -07001036 if (IS_ERR(f)) {
1037 put_unused_fd(fd);
1038 fd = PTR_ERR(f);
1039 } else {
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -08001040 fsnotify_open(f->f_path.dentry);
Telemaque Ndizihiwefed2fc12005-06-23 00:10:33 -07001041 fd_install(fd, f);
1042 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 putname(tmp);
1045 }
1046 return fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047}
Miklos Szeredie922efc2005-09-06 15:18:25 -07001048
Heiko Carstensca013e92009-01-14 14:14:19 +01001049SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
Miklos Szeredie922efc2005-09-06 15:18:25 -07001050{
Linus Torvalds385910f2006-04-18 13:22:59 -07001051 long ret;
1052
Miklos Szeredie922efc2005-09-06 15:18:25 -07001053 if (force_o_largefile())
1054 flags |= O_LARGEFILE;
1055
Linus Torvalds385910f2006-04-18 13:22:59 -07001056 ret = do_sys_open(AT_FDCWD, filename, flags, mode);
1057 /* avoid REGPARM breakage on x86: */
Roland McGrath54a01512008-04-10 15:37:38 -07001058 asmlinkage_protect(3, ret, filename, flags, mode);
Linus Torvalds385910f2006-04-18 13:22:59 -07001059 return ret;
Miklos Szeredie922efc2005-09-06 15:18:25 -07001060}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
Heiko Carstens6559eed82009-01-14 14:14:32 +01001062SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
1063 int, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001064{
Linus Torvalds385910f2006-04-18 13:22:59 -07001065 long ret;
1066
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001067 if (force_o_largefile())
1068 flags |= O_LARGEFILE;
1069
Linus Torvalds385910f2006-04-18 13:22:59 -07001070 ret = do_sys_open(dfd, filename, flags, mode);
1071 /* avoid REGPARM breakage on x86: */
Roland McGrath54a01512008-04-10 15:37:38 -07001072 asmlinkage_protect(4, ret, dfd, filename, flags, mode);
Linus Torvalds385910f2006-04-18 13:22:59 -07001073 return ret;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001074}
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076#ifndef __alpha__
1077
1078/*
1079 * For backward compatibility? Maybe this should be moved
1080 * into arch/i386 instead?
1081 */
Heiko Carstens002c8972009-01-14 14:14:18 +01001082SYSCALL_DEFINE2(creat, const char __user *, pathname, int, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083{
1084 return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1085}
1086
1087#endif
1088
1089/*
1090 * "id" is the POSIX thread ID. We use the
1091 * files pointer for this..
1092 */
1093int filp_close(struct file *filp, fl_owner_t id)
1094{
Christoph Lameter45778ca2005-06-23 00:10:17 -07001095 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
1097 if (!file_count(filp)) {
1098 printk(KERN_ERR "VFS: Close: file count is 0\n");
Christoph Lameter45778ca2005-06-23 00:10:17 -07001099 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 }
1101
Christoph Lameter45778ca2005-06-23 00:10:17 -07001102 if (filp->f_op && filp->f_op->flush)
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001103 retval = filp->f_op->flush(filp, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
1105 dnotify_flush(filp, id);
1106 locks_remove_posix(filp, id);
1107 fput(filp);
1108 return retval;
1109}
1110
1111EXPORT_SYMBOL(filp_close);
1112
1113/*
1114 * Careful here! We test whether the file pointer is NULL before
1115 * releasing the fd. This ensures that one clone task can't release
1116 * an fd while another clone is opening it.
1117 */
Heiko Carstensca013e92009-01-14 14:14:19 +01001118SYSCALL_DEFINE1(close, unsigned int, fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
1120 struct file * filp;
1121 struct files_struct *files = current->files;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001122 struct fdtable *fdt;
Ernie Petridesee731f42006-09-29 02:00:13 -07001123 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
1125 spin_lock(&files->file_lock);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001126 fdt = files_fdtable(files);
1127 if (fd >= fdt->max_fds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 goto out_unlock;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001129 filp = fdt->fd[fd];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 if (!filp)
1131 goto out_unlock;
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -07001132 rcu_assign_pointer(fdt->fd[fd], NULL);
Dipankar Sarmabadf1662005-09-09 13:04:10 -07001133 FD_CLR(fd, fdt->close_on_exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 __put_unused_fd(files, fd);
1135 spin_unlock(&files->file_lock);
Ernie Petridesee731f42006-09-29 02:00:13 -07001136 retval = filp_close(filp, files);
1137
1138 /* can't restart close syscall because file table entry was cleared */
1139 if (unlikely(retval == -ERESTARTSYS ||
1140 retval == -ERESTARTNOINTR ||
1141 retval == -ERESTARTNOHAND ||
1142 retval == -ERESTART_RESTARTBLOCK))
1143 retval = -EINTR;
1144
1145 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
1147out_unlock:
1148 spin_unlock(&files->file_lock);
1149 return -EBADF;
1150}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151EXPORT_SYMBOL(sys_close);
1152
1153/*
1154 * This routine simulates a hangup on the tty, to arrange that users
1155 * are given clean terminals at login time.
1156 */
Heiko Carstensca013e92009-01-14 14:14:19 +01001157SYSCALL_DEFINE0(vhangup)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158{
1159 if (capable(CAP_SYS_TTY_CONFIG)) {
Alan Cox2cb59982008-10-13 10:40:30 +01001160 tty_vhangup_self();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 return 0;
1162 }
1163 return -EPERM;
1164}
1165
1166/*
1167 * Called when an inode is about to be open.
1168 * We use this to disallow opening large files on 32bit systems if
1169 * the caller didn't specify O_LARGEFILE. On 64bit systems we force
1170 * on this flag in sys_open.
1171 */
1172int generic_file_open(struct inode * inode, struct file * filp)
1173{
1174 if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
Alan Coxa9c62a12007-10-16 23:30:22 -07001175 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return 0;
1177}
1178
1179EXPORT_SYMBOL(generic_file_open);
1180
1181/*
1182 * This is used by subsystems that don't want seekable
1183 * file descriptors
1184 */
1185int nonseekable_open(struct inode *inode, struct file *filp)
1186{
1187 filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1188 return 0;
1189}
1190
1191EXPORT_SYMBOL(nonseekable_open);