2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* linux/fs/read_write.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/uio.h>
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-13 04:06:03 +07:00
|
|
|
#include <linux/fsnotify.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/security.h>
|
2011-11-17 11:57:37 +07:00
|
|
|
#include <linux/export.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/syscalls.h>
|
2006-01-05 07:20:40 +07:00
|
|
|
#include <linux/pagemap.h>
|
2007-06-04 14:59:47 +07:00
|
|
|
#include <linux/splice.h>
|
2013-02-24 22:52:26 +07:00
|
|
|
#include <linux/compat.h>
|
2006-10-01 13:28:47 +07:00
|
|
|
#include "read_write.h"
|
2013-03-21 00:19:30 +07:00
|
|
|
#include "internal.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
|
2006-03-28 16:56:42 +07:00
|
|
|
const struct file_operations generic_ro_fops = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.llseek = generic_file_llseek,
|
2006-10-01 13:28:48 +07:00
|
|
|
.read = do_sync_read,
|
|
|
|
.aio_read = generic_file_aio_read,
|
2005-04-17 05:20:36 +07:00
|
|
|
.mmap = generic_file_readonly_mmap,
|
2007-06-01 19:52:37 +07:00
|
|
|
.splice_read = generic_file_splice_read,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(generic_ro_fops);
|
|
|
|
|
2010-12-17 19:44:05 +07:00
|
|
|
static inline int unsigned_offsets(struct file *file)
|
2010-10-02 04:20:22 +07:00
|
|
|
{
|
2010-12-17 19:44:05 +07:00
|
|
|
return file->f_mode & FMODE_UNSIGNED_OFFSET;
|
2010-10-02 04:20:22 +07:00
|
|
|
}
|
|
|
|
|
2011-09-16 06:06:48 +07:00
|
|
|
static loff_t lseek_execute(struct file *file, struct inode *inode,
|
|
|
|
loff_t offset, loff_t maxsize)
|
|
|
|
{
|
|
|
|
if (offset < 0 && !unsigned_offsets(file))
|
|
|
|
return -EINVAL;
|
|
|
|
if (offset > maxsize)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (offset != file->f_pos) {
|
|
|
|
file->f_pos = offset;
|
|
|
|
file->f_version = 0;
|
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2008-08-11 20:37:17 +07:00
|
|
|
/**
|
2011-09-16 06:06:50 +07:00
|
|
|
* generic_file_llseek_size - generic llseek implementation for regular files
|
2008-08-11 20:37:17 +07:00
|
|
|
* @file: file structure to seek on
|
|
|
|
* @offset: file offset to seek to
|
2012-12-18 06:59:39 +07:00
|
|
|
* @whence: type of seek
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
* @size: max size of this file in file system
|
|
|
|
* @eof: offset used for SEEK_END position
|
2008-08-11 20:37:17 +07:00
|
|
|
*
|
2011-09-16 06:06:50 +07:00
|
|
|
* This is a variant of generic_file_llseek that allows passing in a custom
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
* maximum file size and a custom EOF position, for e.g. hashed directories
|
2011-09-16 06:06:48 +07:00
|
|
|
*
|
|
|
|
* Synchronization:
|
2011-09-16 06:06:50 +07:00
|
|
|
* SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
|
2011-09-16 06:06:48 +07:00
|
|
|
* SEEK_CUR is synchronized against other SEEK_CURs, but not read/writes.
|
|
|
|
* read/writes behave like SEEK_SET against seeks.
|
2008-08-11 20:37:17 +07:00
|
|
|
*/
|
2008-06-27 16:05:24 +07:00
|
|
|
loff_t
|
2012-12-18 06:59:39 +07:00
|
|
|
generic_file_llseek_size(struct file *file, loff_t offset, int whence,
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
loff_t maxsize, loff_t eof)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
switch (whence) {
|
2008-08-11 20:37:17 +07:00
|
|
|
case SEEK_END:
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
offset += eof;
|
2008-08-11 20:37:17 +07:00
|
|
|
break;
|
|
|
|
case SEEK_CUR:
|
2008-11-11 08:08:08 +07:00
|
|
|
/*
|
|
|
|
* Here we special-case the lseek(fd, 0, SEEK_CUR)
|
|
|
|
* position-querying operation. Avoid rewriting the "same"
|
|
|
|
* f_pos value back to the file because a concurrent read(),
|
|
|
|
* write() or lseek() might have altered it
|
|
|
|
*/
|
|
|
|
if (offset == 0)
|
|
|
|
return file->f_pos;
|
2011-09-16 06:06:48 +07:00
|
|
|
/*
|
|
|
|
* f_lock protects against read/modify/write race with other
|
|
|
|
* SEEK_CURs. Note that parallel writes and reads behave
|
|
|
|
* like SEEK_SET.
|
|
|
|
*/
|
|
|
|
spin_lock(&file->f_lock);
|
|
|
|
offset = lseek_execute(file, inode, file->f_pos + offset,
|
2011-09-16 06:06:50 +07:00
|
|
|
maxsize);
|
2011-09-16 06:06:48 +07:00
|
|
|
spin_unlock(&file->f_lock);
|
|
|
|
return offset;
|
2011-07-19 00:21:35 +07:00
|
|
|
case SEEK_DATA:
|
|
|
|
/*
|
|
|
|
* In the generic case the entire file is data, so as long as
|
|
|
|
* offset isn't at the end of the file then the offset is data.
|
|
|
|
*/
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
if (offset >= eof)
|
2011-07-19 00:21:35 +07:00
|
|
|
return -ENXIO;
|
|
|
|
break;
|
|
|
|
case SEEK_HOLE:
|
|
|
|
/*
|
|
|
|
* There is a virtual hole at the end of the file, so as long as
|
|
|
|
* offset isn't i_size or larger, return i_size.
|
|
|
|
*/
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
if (offset >= eof)
|
2011-07-19 00:21:35 +07:00
|
|
|
return -ENXIO;
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
offset = eof;
|
2011-07-19 00:21:35 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-08-11 20:37:17 +07:00
|
|
|
|
2011-09-16 06:06:50 +07:00
|
|
|
return lseek_execute(file, inode, offset, maxsize);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(generic_file_llseek_size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* generic_file_llseek - generic llseek implementation for regular files
|
|
|
|
* @file: file structure to seek on
|
|
|
|
* @offset: file offset to seek to
|
2012-12-18 06:59:39 +07:00
|
|
|
* @whence: type of seek
|
2011-09-16 06:06:50 +07:00
|
|
|
*
|
|
|
|
* This is a generic implemenation of ->llseek useable for all normal local
|
|
|
|
* filesystems. It just updates the file offset to the value specified by
|
2012-12-18 06:59:39 +07:00
|
|
|
* @offset and @whence under i_mutex.
|
2011-09-16 06:06:50 +07:00
|
|
|
*/
|
2012-12-18 06:59:39 +07:00
|
|
|
loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
|
2011-09-16 06:06:50 +07:00
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
return generic_file_llseek_size(file, offset, whence,
|
vfs: allow custom EOF in generic_file_llseek code
For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value. Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.
This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position. With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.
As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does. But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.
(Patch also fixes up some comments slightly)
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2012-05-01 01:11:29 +07:00
|
|
|
inode->i_sb->s_maxbytes,
|
|
|
|
i_size_read(inode));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-06-27 16:05:24 +07:00
|
|
|
EXPORT_SYMBOL(generic_file_llseek);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-27 04:44:48 +07:00
|
|
|
/**
|
|
|
|
* noop_llseek - No Operation Performed llseek implementation
|
|
|
|
* @file: file structure to seek on
|
|
|
|
* @offset: file offset to seek to
|
2012-12-18 06:59:39 +07:00
|
|
|
* @whence: type of seek
|
2010-05-27 04:44:48 +07:00
|
|
|
*
|
|
|
|
* This is an implementation of ->llseek useable for the rare special case when
|
|
|
|
* userspace expects the seek to succeed but the (device) file is actually not
|
|
|
|
* able to perform the seek. In this case you use noop_llseek() instead of
|
|
|
|
* falling back to the default implementation of ->llseek.
|
|
|
|
*/
|
2012-12-18 06:59:39 +07:00
|
|
|
loff_t noop_llseek(struct file *file, loff_t offset, int whence)
|
2010-05-27 04:44:48 +07:00
|
|
|
{
|
|
|
|
return file->f_pos;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(noop_llseek);
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
loff_t no_llseek(struct file *file, loff_t offset, int whence)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return -ESPIPE;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(no_llseek);
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
loff_t default_llseek(struct file *file, loff_t offset, int whence)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-01-24 05:07:38 +07:00
|
|
|
struct inode *inode = file_inode(file);
|
2008-04-22 20:09:22 +07:00
|
|
|
loff_t retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-07-19 00:21:35 +07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2012-12-18 06:59:39 +07:00
|
|
|
switch (whence) {
|
2007-05-08 14:24:13 +07:00
|
|
|
case SEEK_END:
|
2011-07-19 00:21:35 +07:00
|
|
|
offset += i_size_read(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2007-05-08 14:24:13 +07:00
|
|
|
case SEEK_CUR:
|
2008-11-11 08:08:08 +07:00
|
|
|
if (offset == 0) {
|
|
|
|
retval = file->f_pos;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
offset += file->f_pos;
|
2011-07-19 00:21:35 +07:00
|
|
|
break;
|
|
|
|
case SEEK_DATA:
|
|
|
|
/*
|
|
|
|
* In the generic case the entire file is data, so as
|
|
|
|
* long as offset isn't at the end of the file then the
|
|
|
|
* offset is data.
|
|
|
|
*/
|
2011-07-26 21:25:20 +07:00
|
|
|
if (offset >= inode->i_size) {
|
|
|
|
retval = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-07-19 00:21:35 +07:00
|
|
|
break;
|
|
|
|
case SEEK_HOLE:
|
|
|
|
/*
|
|
|
|
* There is a virtual hole at the end of the file, so
|
|
|
|
* as long as offset isn't i_size or larger, return
|
|
|
|
* i_size.
|
|
|
|
*/
|
2011-07-26 21:25:20 +07:00
|
|
|
if (offset >= inode->i_size) {
|
|
|
|
retval = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-07-19 00:21:35 +07:00
|
|
|
offset = inode->i_size;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
retval = -EINVAL;
|
2010-12-17 19:44:05 +07:00
|
|
|
if (offset >= 0 || unsigned_offsets(file)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (offset != file->f_pos) {
|
|
|
|
file->f_pos = offset;
|
|
|
|
file->f_version = 0;
|
|
|
|
}
|
|
|
|
retval = offset;
|
|
|
|
}
|
2008-11-11 08:08:08 +07:00
|
|
|
out:
|
2011-07-19 00:21:35 +07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(default_llseek);
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
loff_t (*fn)(struct file *, loff_t, int);
|
|
|
|
|
|
|
|
fn = no_llseek;
|
|
|
|
if (file->f_mode & FMODE_LSEEK) {
|
|
|
|
if (file->f_op && file->f_op->llseek)
|
|
|
|
fn = file->f_op->llseek;
|
|
|
|
}
|
2012-12-18 06:59:39 +07:00
|
|
|
return fn(file, offset, whence);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(vfs_llseek);
|
|
|
|
|
2012-12-18 06:59:39 +07:00
|
|
|
SYSCALL_DEFINE3(lseek, unsigned int, fd, off_t, offset, unsigned int, whence)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
off_t retval;
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
|
|
|
if (!f.file)
|
|
|
|
return -EBADF;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = -EINVAL;
|
2012-12-18 06:59:39 +07:00
|
|
|
if (whence <= SEEK_MAX) {
|
|
|
|
loff_t res = vfs_llseek(f.file, offset, whence);
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = res;
|
|
|
|
if (res != (loff_t)retval)
|
|
|
|
retval = -EOVERFLOW; /* LFS: should only happen on 32 bit platforms */
|
|
|
|
}
|
2012-08-28 23:52:22 +07:00
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2013-02-24 22:52:26 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset, unsigned int, whence)
|
|
|
|
{
|
|
|
|
return sys_lseek(fd, offset, whence);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef __ARCH_WANT_SYS_LLSEEK
|
2009-01-14 20:14:21 +07:00
|
|
|
SYSCALL_DEFINE5(llseek, unsigned int, fd, unsigned long, offset_high,
|
|
|
|
unsigned long, offset_low, loff_t __user *, result,
|
2012-12-18 06:59:39 +07:00
|
|
|
unsigned int, whence)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int retval;
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
2005-04-17 05:20:36 +07:00
|
|
|
loff_t offset;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
if (!f.file)
|
|
|
|
return -EBADF;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = -EINVAL;
|
2012-12-18 06:59:39 +07:00
|
|
|
if (whence > SEEK_MAX)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_putf;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
offset = vfs_llseek(f.file, ((loff_t) offset_high << 32) | offset_low,
|
2012-12-18 06:59:39 +07:00
|
|
|
whence);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = (int)offset;
|
|
|
|
if (offset >= 0) {
|
|
|
|
retval = -EFAULT;
|
|
|
|
if (!copy_to_user(result, &offset, sizeof(offset)))
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
out_putf:
|
2012-08-28 23:52:22 +07:00
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-01-05 07:20:40 +07:00
|
|
|
/*
|
|
|
|
* rw_verify_area doesn't like huge counts. We limit
|
|
|
|
* them to something that fits in "int" so that others
|
|
|
|
* won't have to do range checks all the time.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
loff_t pos;
|
2008-01-12 18:05:48 +07:00
|
|
|
int retval = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-01-24 05:07:38 +07:00
|
|
|
inode = file_inode(file);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (unlikely((ssize_t) count < 0))
|
2008-01-12 18:05:48 +07:00
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
pos = *ppos;
|
2010-12-17 19:44:05 +07:00
|
|
|
if (unlikely(pos < 0)) {
|
|
|
|
if (!unsigned_offsets(file))
|
|
|
|
return retval;
|
|
|
|
if (count >= -pos) /* both values are in 0..LLONG_MAX */
|
|
|
|
return -EOVERFLOW;
|
|
|
|
} else if (unlikely((loff_t) (pos + count) < 0)) {
|
|
|
|
if (!unsigned_offsets(file))
|
2010-10-02 04:20:22 +07:00
|
|
|
return retval;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-02 04:41:11 +07:00
|
|
|
if (unlikely(inode->i_flock && mandatory_lock(inode))) {
|
2008-01-12 18:05:48 +07:00
|
|
|
retval = locks_mandatory_area(
|
2006-01-05 07:20:40 +07:00
|
|
|
read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
|
|
|
|
inode, file, pos, count);
|
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
|
|
|
}
|
2008-01-12 18:05:48 +07:00
|
|
|
retval = security_file_permission(file,
|
|
|
|
read_write == READ ? MAY_READ : MAY_WRITE);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2006-01-05 07:20:40 +07:00
|
|
|
return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-06-23 14:10:27 +07:00
|
|
|
static void wait_on_retry_sync_kiocb(struct kiocb *iocb)
|
|
|
|
{
|
|
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
|
|
if (!kiocbIsKicked(iocb))
|
|
|
|
schedule();
|
|
|
|
else
|
|
|
|
kiocbClearKicked(iocb);
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
|
|
|
|
{
|
2006-10-01 13:28:46 +07:00
|
|
|
struct iovec iov = { .iov_base = buf, .iov_len = len };
|
2005-04-17 05:20:36 +07:00
|
|
|
struct kiocb kiocb;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
init_sync_kiocb(&kiocb, filp);
|
|
|
|
kiocb.ki_pos = *ppos;
|
2006-10-01 13:28:46 +07:00
|
|
|
kiocb.ki_left = len;
|
2010-03-25 00:09:19 +07:00
|
|
|
kiocb.ki_nbytes = len;
|
2006-10-01 13:28:46 +07:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
|
|
|
|
if (ret != -EIOCBRETRY)
|
|
|
|
break;
|
2005-06-23 14:10:27 +07:00
|
|
|
wait_on_retry_sync_kiocb(&kiocb);
|
2006-10-01 13:28:46 +07:00
|
|
|
}
|
2005-06-23 14:10:27 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (-EIOCBQUEUED == ret)
|
|
|
|
ret = wait_on_sync_kiocb(&kiocb);
|
|
|
|
*ppos = kiocb.ki_pos;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(do_sync_read);
|
|
|
|
|
|
|
|
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
|
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (!(file->f_mode & FMODE_READ))
|
|
|
|
return -EBADF;
|
|
|
|
if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
|
|
|
|
return -EINVAL;
|
|
|
|
if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
ret = rw_verify_area(READ, file, pos, count);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (ret >= 0) {
|
|
|
|
count = ret;
|
2008-01-12 18:05:48 +07:00
|
|
|
if (file->f_op->read)
|
|
|
|
ret = file->f_op->read(file, buf, count, pos);
|
|
|
|
else
|
|
|
|
ret = do_sync_read(file, buf, count, pos);
|
|
|
|
if (ret > 0) {
|
2009-12-18 09:24:21 +07:00
|
|
|
fsnotify_access(file);
|
2008-01-12 18:05:48 +07:00
|
|
|
add_rchar(current, ret);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-12 18:05:48 +07:00
|
|
|
inc_syscr(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(vfs_read);
|
|
|
|
|
|
|
|
ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
|
|
|
|
{
|
2006-10-01 13:28:46 +07:00
|
|
|
struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
|
2005-04-17 05:20:36 +07:00
|
|
|
struct kiocb kiocb;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
init_sync_kiocb(&kiocb, filp);
|
|
|
|
kiocb.ki_pos = *ppos;
|
2006-10-01 13:28:46 +07:00
|
|
|
kiocb.ki_left = len;
|
2010-03-25 00:09:19 +07:00
|
|
|
kiocb.ki_nbytes = len;
|
2006-10-01 13:28:46 +07:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
|
|
|
|
if (ret != -EIOCBRETRY)
|
|
|
|
break;
|
2005-06-23 14:10:27 +07:00
|
|
|
wait_on_retry_sync_kiocb(&kiocb);
|
2006-10-01 13:28:46 +07:00
|
|
|
}
|
2005-06-23 14:10:27 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (-EIOCBQUEUED == ret)
|
|
|
|
ret = wait_on_sync_kiocb(&kiocb);
|
|
|
|
*ppos = kiocb.ki_pos;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(do_sync_write);
|
|
|
|
|
2013-03-21 00:19:30 +07:00
|
|
|
ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
|
|
|
|
{
|
|
|
|
mm_segment_t old_fs;
|
|
|
|
const char __user *p;
|
|
|
|
ssize_t ret;
|
|
|
|
|
2013-03-27 22:20:30 +07:00
|
|
|
if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-03-21 00:19:30 +07:00
|
|
|
old_fs = get_fs();
|
|
|
|
set_fs(get_ds());
|
|
|
|
p = (__force const char __user *)buf;
|
|
|
|
if (count > MAX_RW_COUNT)
|
|
|
|
count = MAX_RW_COUNT;
|
|
|
|
if (file->f_op->write)
|
|
|
|
ret = file->f_op->write(file, p, count, pos);
|
|
|
|
else
|
|
|
|
ret = do_sync_write(file, p, count, pos);
|
|
|
|
set_fs(old_fs);
|
|
|
|
if (ret > 0) {
|
|
|
|
fsnotify_modify(file);
|
|
|
|
add_wchar(current, ret);
|
|
|
|
}
|
|
|
|
inc_syscw(current);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
|
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (!(file->f_mode & FMODE_WRITE))
|
|
|
|
return -EBADF;
|
|
|
|
if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
|
|
|
|
return -EINVAL;
|
|
|
|
if (unlikely(!access_ok(VERIFY_READ, buf, count)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
ret = rw_verify_area(WRITE, file, pos, count);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (ret >= 0) {
|
|
|
|
count = ret;
|
2008-01-12 18:05:48 +07:00
|
|
|
if (file->f_op->write)
|
|
|
|
ret = file->f_op->write(file, buf, count, pos);
|
|
|
|
else
|
|
|
|
ret = do_sync_write(file, buf, count, pos);
|
|
|
|
if (ret > 0) {
|
2009-12-18 09:24:21 +07:00
|
|
|
fsnotify_modify(file);
|
2008-01-12 18:05:48 +07:00
|
|
|
add_wchar(current, ret);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-12 18:05:48 +07:00
|
|
|
inc_syscw(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(vfs_write);
|
|
|
|
|
|
|
|
static inline loff_t file_pos_read(struct file *file)
|
|
|
|
{
|
|
|
|
return file->f_pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void file_pos_write(struct file *file, loff_t pos)
|
|
|
|
{
|
|
|
|
file->f_pos = pos;
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:22 +07:00
|
|
|
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file) {
|
|
|
|
loff_t pos = file_pos_read(f.file);
|
|
|
|
ret = vfs_read(f.file, buf, count, &pos);
|
|
|
|
file_pos_write(f.file, pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:22 +07:00
|
|
|
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
|
|
|
|
size_t, count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file) {
|
|
|
|
loff_t pos = file_pos_read(f.file);
|
|
|
|
ret = vfs_write(f.file, buf, count, &pos);
|
|
|
|
file_pos_write(f.file, pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:02 +07:00
|
|
|
SYSCALL_DEFINE(pread64)(unsigned int fd, char __user *buf,
|
|
|
|
size_t count, loff_t pos)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f;
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
f = fdget(fd);
|
|
|
|
if (f.file) {
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = -ESPIPE;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file->f_mode & FMODE_PREAD)
|
|
|
|
ret = vfs_read(f.file, buf, count, &pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-01-14 20:14:02 +07:00
|
|
|
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
|
|
|
|
asmlinkage long SyS_pread64(long fd, long buf, long count, loff_t pos)
|
|
|
|
{
|
|
|
|
return SYSC_pread64((unsigned int) fd, (char __user *) buf,
|
|
|
|
(size_t) count, pos);
|
|
|
|
}
|
|
|
|
SYSCALL_ALIAS(sys_pread64, SyS_pread64);
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-14 20:14:02 +07:00
|
|
|
SYSCALL_DEFINE(pwrite64)(unsigned int fd, const char __user *buf,
|
|
|
|
size_t count, loff_t pos)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f;
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
f = fdget(fd);
|
|
|
|
if (f.file) {
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = -ESPIPE;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file->f_mode & FMODE_PWRITE)
|
|
|
|
ret = vfs_write(f.file, buf, count, &pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-01-14 20:14:02 +07:00
|
|
|
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
|
|
|
|
asmlinkage long SyS_pwrite64(long fd, long buf, long count, loff_t pos)
|
|
|
|
{
|
|
|
|
return SYSC_pwrite64((unsigned int) fd, (const char __user *) buf,
|
|
|
|
(size_t) count, pos);
|
|
|
|
}
|
|
|
|
SYSCALL_ALIAS(sys_pwrite64, SyS_pwrite64);
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reduce an iovec's length in-place. Return the resulting number of segments
|
|
|
|
*/
|
|
|
|
unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
|
|
|
|
{
|
|
|
|
unsigned long seg = 0;
|
|
|
|
size_t len = 0;
|
|
|
|
|
|
|
|
while (seg < nr_segs) {
|
|
|
|
seg++;
|
|
|
|
if (len + iov->iov_len >= to) {
|
|
|
|
iov->iov_len = to - len;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
len += iov->iov_len;
|
|
|
|
iov++;
|
|
|
|
}
|
|
|
|
return seg;
|
|
|
|
}
|
2008-01-29 11:58:27 +07:00
|
|
|
EXPORT_SYMBOL(iov_shorten);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-01 13:28:47 +07:00
|
|
|
ssize_t do_sync_readv_writev(struct file *filp, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, size_t len, loff_t *ppos, iov_fn_t fn)
|
|
|
|
{
|
|
|
|
struct kiocb kiocb;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
init_sync_kiocb(&kiocb, filp);
|
|
|
|
kiocb.ki_pos = *ppos;
|
|
|
|
kiocb.ki_left = len;
|
|
|
|
kiocb.ki_nbytes = len;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
ret = fn(&kiocb, iov, nr_segs, kiocb.ki_pos);
|
|
|
|
if (ret != -EIOCBRETRY)
|
|
|
|
break;
|
|
|
|
wait_on_retry_sync_kiocb(&kiocb);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == -EIOCBQUEUED)
|
|
|
|
ret = wait_on_sync_kiocb(&kiocb);
|
|
|
|
*ppos = kiocb.ki_pos;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do it by hand, with file-ops */
|
|
|
|
ssize_t do_loop_readv_writev(struct file *filp, struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t *ppos, io_fn_t fn)
|
|
|
|
{
|
|
|
|
struct iovec *vector = iov;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
while (nr_segs > 0) {
|
|
|
|
void __user *base;
|
|
|
|
size_t len;
|
|
|
|
ssize_t nr;
|
|
|
|
|
|
|
|
base = vector->iov_base;
|
|
|
|
len = vector->iov_len;
|
|
|
|
vector++;
|
|
|
|
nr_segs--;
|
|
|
|
|
|
|
|
nr = fn(filp, base, len, ppos);
|
|
|
|
|
|
|
|
if (nr < 0) {
|
|
|
|
if (!ret)
|
|
|
|
ret = nr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret += nr;
|
|
|
|
if (nr != len)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* A write operation does a read from user space and vice versa */
|
|
|
|
#define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
|
|
|
|
|
2006-10-01 13:28:49 +07:00
|
|
|
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
|
|
|
|
unsigned long nr_segs, unsigned long fast_segs,
|
|
|
|
struct iovec *fast_pointer,
|
2012-06-01 06:26:42 +07:00
|
|
|
struct iovec **ret_pointer)
|
2010-10-30 00:36:49 +07:00
|
|
|
{
|
2006-10-01 13:28:49 +07:00
|
|
|
unsigned long seg;
|
2010-10-30 00:36:49 +07:00
|
|
|
ssize_t ret;
|
2006-10-01 13:28:49 +07:00
|
|
|
struct iovec *iov = fast_pointer;
|
|
|
|
|
2010-10-30 00:36:49 +07:00
|
|
|
/*
|
|
|
|
* SuS says "The readv() function *may* fail if the iovcnt argument
|
|
|
|
* was less than or equal to 0, or greater than {IOV_MAX}. Linux has
|
|
|
|
* traditionally returned zero for zero segments, so...
|
|
|
|
*/
|
2006-10-01 13:28:49 +07:00
|
|
|
if (nr_segs == 0) {
|
|
|
|
ret = 0;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
|
|
|
|
2010-10-30 00:36:49 +07:00
|
|
|
/*
|
|
|
|
* First get the "struct iovec" from user memory and
|
|
|
|
* verify all the pointers
|
|
|
|
*/
|
2006-10-01 13:28:49 +07:00
|
|
|
if (nr_segs > UIO_MAXIOV) {
|
|
|
|
ret = -EINVAL;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
|
|
|
if (nr_segs > fast_segs) {
|
2010-10-30 00:36:49 +07:00
|
|
|
iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
|
2006-10-01 13:28:49 +07:00
|
|
|
if (iov == NULL) {
|
|
|
|
ret = -ENOMEM;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
2010-10-30 00:36:49 +07:00
|
|
|
}
|
2006-10-01 13:28:49 +07:00
|
|
|
if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
|
|
|
|
ret = -EFAULT;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
|
|
|
|
2010-10-30 00:36:49 +07:00
|
|
|
/*
|
2006-10-01 13:28:49 +07:00
|
|
|
* According to the Single Unix Specification we should return EINVAL
|
|
|
|
* if an element length is < 0 when cast to ssize_t or if the
|
|
|
|
* total length would overflow the ssize_t return value of the
|
|
|
|
* system call.
|
2010-10-30 00:36:49 +07:00
|
|
|
*
|
|
|
|
* Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
|
|
|
|
* overflow case.
|
|
|
|
*/
|
2006-10-01 13:28:49 +07:00
|
|
|
ret = 0;
|
2010-10-30 00:36:49 +07:00
|
|
|
for (seg = 0; seg < nr_segs; seg++) {
|
|
|
|
void __user *buf = iov[seg].iov_base;
|
|
|
|
ssize_t len = (ssize_t)iov[seg].iov_len;
|
2006-10-01 13:28:49 +07:00
|
|
|
|
|
|
|
/* see if we we're about to use an invalid len or if
|
|
|
|
* it's about to overflow ssize_t */
|
2010-10-30 00:36:49 +07:00
|
|
|
if (len < 0) {
|
2006-10-01 13:28:49 +07:00
|
|
|
ret = -EINVAL;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
2012-06-01 06:26:42 +07:00
|
|
|
if (type >= 0
|
2011-11-01 07:06:39 +07:00
|
|
|
&& unlikely(!access_ok(vrfy_dir(type), buf, len))) {
|
2006-10-01 13:28:49 +07:00
|
|
|
ret = -EFAULT;
|
2010-10-30 00:36:49 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (len > MAX_RW_COUNT - ret) {
|
|
|
|
len = MAX_RW_COUNT - ret;
|
|
|
|
iov[seg].iov_len = len;
|
2006-10-01 13:28:49 +07:00
|
|
|
}
|
|
|
|
ret += len;
|
2010-10-30 00:36:49 +07:00
|
|
|
}
|
2006-10-01 13:28:49 +07:00
|
|
|
out:
|
|
|
|
*ret_pointer = iov;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static ssize_t do_readv_writev(int type, struct file *file,
|
|
|
|
const struct iovec __user * uvector,
|
|
|
|
unsigned long nr_segs, loff_t *pos)
|
|
|
|
{
|
|
|
|
size_t tot_len;
|
|
|
|
struct iovec iovstack[UIO_FASTIOV];
|
2006-10-01 13:28:47 +07:00
|
|
|
struct iovec *iov = iovstack;
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret;
|
|
|
|
io_fn_t fn;
|
|
|
|
iov_fn_t fnv;
|
|
|
|
|
2006-10-01 13:28:49 +07:00
|
|
|
if (!file->f_op) {
|
|
|
|
ret = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2006-10-01 13:28:49 +07:00
|
|
|
ret = rw_copy_check_uvector(type, uvector, nr_segs,
|
2012-06-01 06:26:42 +07:00
|
|
|
ARRAY_SIZE(iovstack), iovstack, &iov);
|
2006-10-01 13:28:49 +07:00
|
|
|
if (ret <= 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2006-10-01 13:28:49 +07:00
|
|
|
tot_len = ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = rw_verify_area(type, file, pos, tot_len);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (ret < 0)
|
2005-09-28 22:21:28 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
fnv = NULL;
|
|
|
|
if (type == READ) {
|
|
|
|
fn = file->f_op->read;
|
2006-10-01 13:28:47 +07:00
|
|
|
fnv = file->f_op->aio_read;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
fn = (io_fn_t)file->f_op->write;
|
2006-10-01 13:28:47 +07:00
|
|
|
fnv = file->f_op->aio_write;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-10-01 13:28:47 +07:00
|
|
|
if (fnv)
|
|
|
|
ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
|
|
|
|
pos, fnv);
|
|
|
|
else
|
|
|
|
ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (iov != iovstack)
|
|
|
|
kfree(iov);
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-13 04:06:03 +07:00
|
|
|
if ((ret + (type == READ)) > 0) {
|
|
|
|
if (type == READ)
|
2009-12-18 09:24:21 +07:00
|
|
|
fsnotify_access(file);
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-13 04:06:03 +07:00
|
|
|
else
|
2009-12-18 09:24:21 +07:00
|
|
|
fsnotify_modify(file);
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-13 04:06:03 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
|
|
|
|
unsigned long vlen, loff_t *pos)
|
|
|
|
{
|
|
|
|
if (!(file->f_mode & FMODE_READ))
|
|
|
|
return -EBADF;
|
2006-10-01 13:28:47 +07:00
|
|
|
if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return do_readv_writev(READ, file, vec, vlen, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(vfs_readv);
|
|
|
|
|
|
|
|
ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
|
|
|
|
unsigned long vlen, loff_t *pos)
|
|
|
|
{
|
|
|
|
if (!(file->f_mode & FMODE_WRITE))
|
|
|
|
return -EBADF;
|
2006-10-01 13:28:47 +07:00
|
|
|
if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return do_readv_writev(WRITE, file, vec, vlen, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(vfs_writev);
|
|
|
|
|
2009-01-14 20:14:22 +07:00
|
|
|
SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
|
|
|
|
unsigned long, vlen)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file) {
|
|
|
|
loff_t pos = file_pos_read(f.file);
|
|
|
|
ret = vfs_readv(f.file, vec, vlen, &pos);
|
|
|
|
file_pos_write(f.file, pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0)
|
[PATCH] ifdef ->rchar, ->wchar, ->syscr, ->syscw from task_struct
They are fat: 4x8 bytes in task_struct.
They are uncoditionally updated in every fork, read, write and sendfile.
They are used only if you have some "extended acct fields feature".
And please, please, please, read(2) knows about bytes, not characters,
why it is called "rchar"?
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Jay Lan <jlan@engr.sgi.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-10 16:46:45 +07:00
|
|
|
add_rchar(current, ret);
|
|
|
|
inc_syscr(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:22 +07:00
|
|
|
SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
|
|
|
|
unsigned long, vlen)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f = fdget(fd);
|
2005-04-17 05:20:36 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file) {
|
|
|
|
loff_t pos = file_pos_read(f.file);
|
|
|
|
ret = vfs_writev(f.file, vec, vlen, &pos);
|
|
|
|
file_pos_write(f.file, pos);
|
|
|
|
fdput(f);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0)
|
[PATCH] ifdef ->rchar, ->wchar, ->syscr, ->syscw from task_struct
They are fat: 4x8 bytes in task_struct.
They are uncoditionally updated in every fork, read, write and sendfile.
They are used only if you have some "extended acct fields feature".
And please, please, please, read(2) knows about bytes, not characters,
why it is called "rchar"?
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Jay Lan <jlan@engr.sgi.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-10 16:46:45 +07:00
|
|
|
add_wchar(current, ret);
|
|
|
|
inc_syscw(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Make non-compat preadv/pwritev use native register size
Instead of always splitting the file offset into 32-bit 'high' and 'low'
parts, just split them into the largest natural word-size - which in C
terms is 'unsigned long'.
This allows 64-bit architectures to avoid the unnecessary 32-bit
shifting and masking for native format (while the compat interfaces will
obviously always have to do it).
This also changes the order of 'high' and 'low' to be "low first". Why?
Because when we have it like this, the 64-bit system calls now don't use
the "pos_high" argument at all, and it makes more sense for the native
system call to simply match the user-mode prototype.
This results in a much more natural calling convention, and allows the
compiler to generate much more straightforward code. On x86-64, we now
generate
testq %rcx, %rcx # pos_l
js .L122 #,
movq %rcx, -48(%rbp) # pos_l, pos
from the C source
loff_t pos = pos_from_hilo(pos_h, pos_l);
...
if (pos < 0)
return -EINVAL;
and the 'pos_h' register isn't even touched. It used to generate code
like
mov %r8d, %r8d # pos_low, pos_low
salq $32, %rcx #, tmp71
movq %r8, %rax # pos_low, pos.386
orq %rcx, %rax # tmp71, pos.386
js .L122 #,
movq %rax, -48(%rbp) # pos.386, pos
which isn't _that_ horrible, but it does show how the natural word size
is just a more sensible interface (same arguments will hold in the user
level glibc wrapper function, of course, so the kernel side is just half
of the equation!)
Note: in all cases the user code wrapper can again be the same. You can
just do
#define HALF_BITS (sizeof(unsigned long)*4)
__syscall(PWRITEV, fd, iov, count, offset, (offset >> HALF_BITS) >> HALF_BITS);
or something like that. That way the user mode wrapper will also be
nicely passing in a zero (it won't actually have to do the shifts, the
compiler will understand what is going on) for the last argument.
And that is a good idea, even if nobody will necessarily ever care: if
we ever do move to a 128-bit lloff_t, this particular system call might
be left alone. Of course, that will be the least of our worries if we
really ever need to care, so this may not be worth really caring about.
[ Fixed for lost 'loff_t' cast noticed by Andrew Morton ]
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: linux-api@vger.kernel.org
Cc: linux-arch@vger.kernel.org
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Ralf Baechle <ralf@linux-mips.org>>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 22:03:22 +07:00
|
|
|
static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
|
|
|
|
{
|
|
|
|
#define HALF_LONG_BITS (BITS_PER_LONG / 2)
|
|
|
|
return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
|
|
|
|
}
|
|
|
|
|
2009-04-03 06:59:23 +07:00
|
|
|
SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
|
Make non-compat preadv/pwritev use native register size
Instead of always splitting the file offset into 32-bit 'high' and 'low'
parts, just split them into the largest natural word-size - which in C
terms is 'unsigned long'.
This allows 64-bit architectures to avoid the unnecessary 32-bit
shifting and masking for native format (while the compat interfaces will
obviously always have to do it).
This also changes the order of 'high' and 'low' to be "low first". Why?
Because when we have it like this, the 64-bit system calls now don't use
the "pos_high" argument at all, and it makes more sense for the native
system call to simply match the user-mode prototype.
This results in a much more natural calling convention, and allows the
compiler to generate much more straightforward code. On x86-64, we now
generate
testq %rcx, %rcx # pos_l
js .L122 #,
movq %rcx, -48(%rbp) # pos_l, pos
from the C source
loff_t pos = pos_from_hilo(pos_h, pos_l);
...
if (pos < 0)
return -EINVAL;
and the 'pos_h' register isn't even touched. It used to generate code
like
mov %r8d, %r8d # pos_low, pos_low
salq $32, %rcx #, tmp71
movq %r8, %rax # pos_low, pos.386
orq %rcx, %rax # tmp71, pos.386
js .L122 #,
movq %rax, -48(%rbp) # pos.386, pos
which isn't _that_ horrible, but it does show how the natural word size
is just a more sensible interface (same arguments will hold in the user
level glibc wrapper function, of course, so the kernel side is just half
of the equation!)
Note: in all cases the user code wrapper can again be the same. You can
just do
#define HALF_BITS (sizeof(unsigned long)*4)
__syscall(PWRITEV, fd, iov, count, offset, (offset >> HALF_BITS) >> HALF_BITS);
or something like that. That way the user mode wrapper will also be
nicely passing in a zero (it won't actually have to do the shifts, the
compiler will understand what is going on) for the last argument.
And that is a good idea, even if nobody will necessarily ever care: if
we ever do move to a 128-bit lloff_t, this particular system call might
be left alone. Of course, that will be the least of our worries if we
really ever need to care, so this may not be worth really caring about.
[ Fixed for lost 'loff_t' cast noticed by Andrew Morton ]
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: linux-api@vger.kernel.org
Cc: linux-arch@vger.kernel.org
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Ralf Baechle <ralf@linux-mips.org>>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 22:03:22 +07:00
|
|
|
unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
|
2009-04-03 06:59:23 +07:00
|
|
|
{
|
Make non-compat preadv/pwritev use native register size
Instead of always splitting the file offset into 32-bit 'high' and 'low'
parts, just split them into the largest natural word-size - which in C
terms is 'unsigned long'.
This allows 64-bit architectures to avoid the unnecessary 32-bit
shifting and masking for native format (while the compat interfaces will
obviously always have to do it).
This also changes the order of 'high' and 'low' to be "low first". Why?
Because when we have it like this, the 64-bit system calls now don't use
the "pos_high" argument at all, and it makes more sense for the native
system call to simply match the user-mode prototype.
This results in a much more natural calling convention, and allows the
compiler to generate much more straightforward code. On x86-64, we now
generate
testq %rcx, %rcx # pos_l
js .L122 #,
movq %rcx, -48(%rbp) # pos_l, pos
from the C source
loff_t pos = pos_from_hilo(pos_h, pos_l);
...
if (pos < 0)
return -EINVAL;
and the 'pos_h' register isn't even touched. It used to generate code
like
mov %r8d, %r8d # pos_low, pos_low
salq $32, %rcx #, tmp71
movq %r8, %rax # pos_low, pos.386
orq %rcx, %rax # tmp71, pos.386
js .L122 #,
movq %rax, -48(%rbp) # pos.386, pos
which isn't _that_ horrible, but it does show how the natural word size
is just a more sensible interface (same arguments will hold in the user
level glibc wrapper function, of course, so the kernel side is just half
of the equation!)
Note: in all cases the user code wrapper can again be the same. You can
just do
#define HALF_BITS (sizeof(unsigned long)*4)
__syscall(PWRITEV, fd, iov, count, offset, (offset >> HALF_BITS) >> HALF_BITS);
or something like that. That way the user mode wrapper will also be
nicely passing in a zero (it won't actually have to do the shifts, the
compiler will understand what is going on) for the last argument.
And that is a good idea, even if nobody will necessarily ever care: if
we ever do move to a 128-bit lloff_t, this particular system call might
be left alone. Of course, that will be the least of our worries if we
really ever need to care, so this may not be worth really caring about.
[ Fixed for lost 'loff_t' cast noticed by Andrew Morton ]
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: linux-api@vger.kernel.org
Cc: linux-arch@vger.kernel.org
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Ralf Baechle <ralf@linux-mips.org>>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 22:03:22 +07:00
|
|
|
loff_t pos = pos_from_hilo(pos_h, pos_l);
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f;
|
2009-04-03 06:59:23 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
f = fdget(fd);
|
|
|
|
if (f.file) {
|
2009-04-03 06:59:23 +07:00
|
|
|
ret = -ESPIPE;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file->f_mode & FMODE_PREAD)
|
|
|
|
ret = vfs_readv(f.file, vec, vlen, &pos);
|
|
|
|
fdput(f);
|
2009-04-03 06:59:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0)
|
|
|
|
add_rchar(current, ret);
|
|
|
|
inc_syscr(current);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
|
Make non-compat preadv/pwritev use native register size
Instead of always splitting the file offset into 32-bit 'high' and 'low'
parts, just split them into the largest natural word-size - which in C
terms is 'unsigned long'.
This allows 64-bit architectures to avoid the unnecessary 32-bit
shifting and masking for native format (while the compat interfaces will
obviously always have to do it).
This also changes the order of 'high' and 'low' to be "low first". Why?
Because when we have it like this, the 64-bit system calls now don't use
the "pos_high" argument at all, and it makes more sense for the native
system call to simply match the user-mode prototype.
This results in a much more natural calling convention, and allows the
compiler to generate much more straightforward code. On x86-64, we now
generate
testq %rcx, %rcx # pos_l
js .L122 #,
movq %rcx, -48(%rbp) # pos_l, pos
from the C source
loff_t pos = pos_from_hilo(pos_h, pos_l);
...
if (pos < 0)
return -EINVAL;
and the 'pos_h' register isn't even touched. It used to generate code
like
mov %r8d, %r8d # pos_low, pos_low
salq $32, %rcx #, tmp71
movq %r8, %rax # pos_low, pos.386
orq %rcx, %rax # tmp71, pos.386
js .L122 #,
movq %rax, -48(%rbp) # pos.386, pos
which isn't _that_ horrible, but it does show how the natural word size
is just a more sensible interface (same arguments will hold in the user
level glibc wrapper function, of course, so the kernel side is just half
of the equation!)
Note: in all cases the user code wrapper can again be the same. You can
just do
#define HALF_BITS (sizeof(unsigned long)*4)
__syscall(PWRITEV, fd, iov, count, offset, (offset >> HALF_BITS) >> HALF_BITS);
or something like that. That way the user mode wrapper will also be
nicely passing in a zero (it won't actually have to do the shifts, the
compiler will understand what is going on) for the last argument.
And that is a good idea, even if nobody will necessarily ever care: if
we ever do move to a 128-bit lloff_t, this particular system call might
be left alone. Of course, that will be the least of our worries if we
really ever need to care, so this may not be worth really caring about.
[ Fixed for lost 'loff_t' cast noticed by Andrew Morton ]
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: linux-api@vger.kernel.org
Cc: linux-arch@vger.kernel.org
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Ralf Baechle <ralf@linux-mips.org>>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 22:03:22 +07:00
|
|
|
unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
|
2009-04-03 06:59:23 +07:00
|
|
|
{
|
Make non-compat preadv/pwritev use native register size
Instead of always splitting the file offset into 32-bit 'high' and 'low'
parts, just split them into the largest natural word-size - which in C
terms is 'unsigned long'.
This allows 64-bit architectures to avoid the unnecessary 32-bit
shifting and masking for native format (while the compat interfaces will
obviously always have to do it).
This also changes the order of 'high' and 'low' to be "low first". Why?
Because when we have it like this, the 64-bit system calls now don't use
the "pos_high" argument at all, and it makes more sense for the native
system call to simply match the user-mode prototype.
This results in a much more natural calling convention, and allows the
compiler to generate much more straightforward code. On x86-64, we now
generate
testq %rcx, %rcx # pos_l
js .L122 #,
movq %rcx, -48(%rbp) # pos_l, pos
from the C source
loff_t pos = pos_from_hilo(pos_h, pos_l);
...
if (pos < 0)
return -EINVAL;
and the 'pos_h' register isn't even touched. It used to generate code
like
mov %r8d, %r8d # pos_low, pos_low
salq $32, %rcx #, tmp71
movq %r8, %rax # pos_low, pos.386
orq %rcx, %rax # tmp71, pos.386
js .L122 #,
movq %rax, -48(%rbp) # pos.386, pos
which isn't _that_ horrible, but it does show how the natural word size
is just a more sensible interface (same arguments will hold in the user
level glibc wrapper function, of course, so the kernel side is just half
of the equation!)
Note: in all cases the user code wrapper can again be the same. You can
just do
#define HALF_BITS (sizeof(unsigned long)*4)
__syscall(PWRITEV, fd, iov, count, offset, (offset >> HALF_BITS) >> HALF_BITS);
or something like that. That way the user mode wrapper will also be
nicely passing in a zero (it won't actually have to do the shifts, the
compiler will understand what is going on) for the last argument.
And that is a good idea, even if nobody will necessarily ever care: if
we ever do move to a 128-bit lloff_t, this particular system call might
be left alone. Of course, that will be the least of our worries if we
really ever need to care, so this may not be worth really caring about.
[ Fixed for lost 'loff_t' cast noticed by Andrew Morton ]
Acked-by: Gerd Hoffmann <kraxel@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: linux-api@vger.kernel.org
Cc: linux-arch@vger.kernel.org
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Ralf Baechle <ralf@linux-mips.org>>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 22:03:22 +07:00
|
|
|
loff_t pos = pos_from_hilo(pos_h, pos_l);
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd f;
|
2009-04-03 06:59:23 +07:00
|
|
|
ssize_t ret = -EBADF;
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-28 23:52:22 +07:00
|
|
|
f = fdget(fd);
|
|
|
|
if (f.file) {
|
2009-04-03 06:59:23 +07:00
|
|
|
ret = -ESPIPE;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (f.file->f_mode & FMODE_PWRITE)
|
|
|
|
ret = vfs_writev(f.file, vec, vlen, &pos);
|
|
|
|
fdput(f);
|
2009-04-03 06:59:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0)
|
|
|
|
add_wchar(current, ret);
|
|
|
|
inc_syscw(current);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-19 18:01:52 +07:00
|
|
|
ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos, size_t count,
|
|
|
|
loff_t max)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-08-28 23:52:22 +07:00
|
|
|
struct fd in, out;
|
|
|
|
struct inode *in_inode, *out_inode;
|
2005-04-17 05:20:36 +07:00
|
|
|
loff_t pos;
|
|
|
|
ssize_t retval;
|
2012-08-28 23:52:22 +07:00
|
|
|
int fl;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get input file, and verify that it is ok..
|
|
|
|
*/
|
|
|
|
retval = -EBADF;
|
2012-08-28 23:52:22 +07:00
|
|
|
in = fdget(in_fd);
|
|
|
|
if (!in.file)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (!(in.file->f_mode & FMODE_READ))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_in;
|
|
|
|
retval = -ESPIPE;
|
|
|
|
if (!ppos)
|
2012-08-28 23:52:22 +07:00
|
|
|
ppos = &in.file->f_pos;
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2012-08-28 23:52:22 +07:00
|
|
|
if (!(in.file->f_mode & FMODE_PREAD))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_in;
|
2012-08-28 23:52:22 +07:00
|
|
|
retval = rw_verify_area(READ, in.file, ppos, count);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (retval < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_in;
|
2006-01-05 07:20:40 +07:00
|
|
|
count = retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get output file, and verify that it is ok..
|
|
|
|
*/
|
|
|
|
retval = -EBADF;
|
2012-08-28 23:52:22 +07:00
|
|
|
out = fdget(out_fd);
|
|
|
|
if (!out.file)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_in;
|
2012-08-28 23:52:22 +07:00
|
|
|
if (!(out.file->f_mode & FMODE_WRITE))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_out;
|
|
|
|
retval = -EINVAL;
|
2013-01-24 05:07:38 +07:00
|
|
|
in_inode = file_inode(in.file);
|
|
|
|
out_inode = file_inode(out.file);
|
2012-08-28 23:52:22 +07:00
|
|
|
retval = rw_verify_area(WRITE, out.file, &out.file->f_pos, count);
|
2006-01-05 07:20:40 +07:00
|
|
|
if (retval < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto fput_out;
|
2006-01-05 07:20:40 +07:00
|
|
|
count = retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!max)
|
|
|
|
max = min(in_inode->i_sb->s_maxbytes, out_inode->i_sb->s_maxbytes);
|
|
|
|
|
|
|
|
pos = *ppos;
|
|
|
|
if (unlikely(pos + count > max)) {
|
|
|
|
retval = -EOVERFLOW;
|
|
|
|
if (pos >= max)
|
|
|
|
goto fput_out;
|
|
|
|
count = max - pos;
|
|
|
|
}
|
|
|
|
|
2007-06-11 17:18:52 +07:00
|
|
|
fl = 0;
|
2007-06-01 19:52:37 +07:00
|
|
|
#if 0
|
2007-06-11 17:18:52 +07:00
|
|
|
/*
|
|
|
|
* We need to debate whether we can enable this or not. The
|
|
|
|
* man page documents EAGAIN return for the output at least,
|
|
|
|
* and the application is arguably buggy if it doesn't expect
|
|
|
|
* EAGAIN on a non-blocking file descriptor.
|
|
|
|
*/
|
2012-08-28 23:52:22 +07:00
|
|
|
if (in.file->f_flags & O_NONBLOCK)
|
2007-06-11 17:18:52 +07:00
|
|
|
fl = SPLICE_F_NONBLOCK;
|
2007-06-01 19:52:37 +07:00
|
|
|
#endif
|
2012-08-28 23:52:22 +07:00
|
|
|
retval = do_splice_direct(in.file, ppos, out.file, count, fl);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (retval > 0) {
|
[PATCH] ifdef ->rchar, ->wchar, ->syscr, ->syscw from task_struct
They are fat: 4x8 bytes in task_struct.
They are uncoditionally updated in every fork, read, write and sendfile.
They are used only if you have some "extended acct fields feature".
And please, please, please, read(2) knows about bytes, not characters,
why it is called "rchar"?
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Jay Lan <jlan@engr.sgi.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-10 16:46:45 +07:00
|
|
|
add_rchar(current, retval);
|
|
|
|
add_wchar(current, retval);
|
2012-12-21 06:05:52 +07:00
|
|
|
fsnotify_access(in.file);
|
|
|
|
fsnotify_modify(out.file);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
[PATCH] ifdef ->rchar, ->wchar, ->syscr, ->syscw from task_struct
They are fat: 4x8 bytes in task_struct.
They are uncoditionally updated in every fork, read, write and sendfile.
They are used only if you have some "extended acct fields feature".
And please, please, please, read(2) knows about bytes, not characters,
why it is called "rchar"?
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Jay Lan <jlan@engr.sgi.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-10 16:46:45 +07:00
|
|
|
inc_syscr(current);
|
|
|
|
inc_syscw(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (*ppos > max)
|
|
|
|
retval = -EOVERFLOW;
|
|
|
|
|
|
|
|
fput_out:
|
2012-08-28 23:52:22 +07:00
|
|
|
fdput(out);
|
2005-04-17 05:20:36 +07:00
|
|
|
fput_in:
|
2012-08-28 23:52:22 +07:00
|
|
|
fdput(in);
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:18 +07:00
|
|
|
SYSCALL_DEFINE4(sendfile, int, out_fd, int, in_fd, off_t __user *, offset, size_t, count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
loff_t pos;
|
|
|
|
off_t off;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (offset) {
|
|
|
|
if (unlikely(get_user(off, offset)))
|
|
|
|
return -EFAULT;
|
|
|
|
pos = off;
|
|
|
|
ret = do_sendfile(out_fd, in_fd, &pos, count, MAX_NON_LFS);
|
|
|
|
if (unlikely(put_user(pos, offset)))
|
|
|
|
return -EFAULT;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return do_sendfile(out_fd, in_fd, NULL, count, 0);
|
|
|
|
}
|
|
|
|
|
2009-01-14 20:14:18 +07:00
|
|
|
SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, loff_t __user *, offset, size_t, count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
loff_t pos;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (offset) {
|
|
|
|
if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
|
|
|
|
return -EFAULT;
|
|
|
|
ret = do_sendfile(out_fd, in_fd, &pos, count, 0);
|
|
|
|
if (unlikely(put_user(pos, offset)))
|
|
|
|
return -EFAULT;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return do_sendfile(out_fd, in_fd, NULL, count, 0);
|
|
|
|
}
|