static
ssize_t svfs_file_splice_read(struct file *in, loff_t *ppos,
struct pipe_inode_info *pipe, size_t len,
unsigned int flags)
{
int ret;
struct file *llfs_file;
struct svfs_inode *si;
svfs_entry(mdc, "pos %lu, len %ld, flags 0x%x\n", (unsigned long)*ppos,
(long)len, flags);
/* we should change the file struct here! */
si = SVFS_I(in->f_dentry->d_inode);
if (si->state & SVFS_STATE_DA) {
/* create it now */
ASSERT(!(si->state & SVFS_STATE_CONN));
ret = llfs_create(in->f_dentry);
if (ret)
goto out;
}
if (!(si->state & SVFS_STATE_CONN)) {
/* open it ? */
ret = llfs_lookup(in->f_dentry->d_inode);
if (ret)
goto out;
}
llfs_file = si->llfs_md.llfs_filp;
ASSERT(llfs_filp);
ret = generic_file_splice_read(llfs_file, ppos, pipe, len, flags);
out:
return ret;
}
STATIC ssize_t
xfs_file_splice_read(
struct file *infilp,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t count,
unsigned int flags)
{
struct xfs_inode *ip = XFS_I(infilp->f_mapping->host);
int ioflags = 0;
ssize_t ret;
XFS_STATS_INC(xs_read_calls);
if (infilp->f_mode & FMODE_NOCMTIME)
ioflags |= IO_INVIS;
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
if (ret > 0)
XFS_STATS_ADD(xs_read_bytes, ret);
xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
return ret;
}
static ssize_t ocfs2_file_splice_read(struct file *in,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t len,
unsigned int flags)
{
int ret = 0;
struct inode *inode = in->f_path.dentry->d_inode;
mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
(unsigned int)len,
in->f_path.dentry->d_name.len,
in->f_path.dentry->d_name.name);
/*
* See the comment in ocfs2_file_aio_read()
*/
ret = ocfs2_meta_lock(inode, NULL, 0);
if (ret < 0) {
mlog_errno(ret);
goto bail;
}
ocfs2_meta_unlock(inode, 0);
ret = generic_file_splice_read(in, ppos, pipe, len, flags);
bail:
mlog_exit(ret);
return ret;
}
static ssize_t
HgfsSpliceRead(struct file *file, // IN: File to read from
loff_t *offset, // IN/OUT: Where to start reading
struct pipe_inode_info *pipe, // IN: Pipe where to write data
size_t len, // IN: How much to read
unsigned int flags) // IN: Various flags
{
ssize_t result;
ASSERT(file);
ASSERT(file->f_dentry);
LOG(6, (KERN_DEBUG "VMware hgfs: HgfsSpliceRead: was called\n"));
result = HgfsRevalidate(file->f_dentry);
if (result) {
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsSpliceRead: invalid dentry\n"));
goto out;
}
result = generic_file_splice_read(file, offset, pipe, len, flags);
out:
return result;
}
ssize_t testfs_splice_read(struct file *in, loff_t *ppos, struct pipe_inode_info *pipe, size_t len, unsigned int flags)
{
int ret = 0;
printk(KERN_INFO "testfs: testfs_splice_read\n");
ret = generic_file_splice_read(in, ppos, pipe, len, flags);
return ret;
}
static ssize_t
nfs_file_splice_read(struct file *filp, loff_t *ppos,
struct pipe_inode_info *pipe, size_t count,
unsigned int flags)
{
struct dentry *dentry = filp->f_path.dentry;
struct inode *inode = dentry->d_inode;
ssize_t res;
dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
dentry->d_parent->d_name.name, dentry->d_name.name,
(unsigned long) count, (unsigned long long) *ppos);
res = nfs_revalidate_mapping(inode, filp->f_mapping);
if (!res)
res = generic_file_splice_read(filp, ppos, pipe, count, flags);
return res;
}
STATIC ssize_t
xfs_file_splice_read(
struct file *infilp,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t count,
unsigned int flags)
{
struct xfs_inode *ip = XFS_I(infilp->f_mapping->host);
struct xfs_mount *mp = ip->i_mount;
int ioflags = 0;
ssize_t ret;
XFS_STATS_INC(xs_read_calls);
if (infilp->f_mode & FMODE_NOCMTIME)
ioflags |= IO_INVIS;
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
xfs_ilock(ip, XFS_IOLOCK_SHARED);
if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
int iolock = XFS_IOLOCK_SHARED;
int error;
error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, *ppos, count,
FILP_DELAY_FLAG(infilp), &iolock);
if (error) {
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return -error;
}
}
trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
if (ret > 0)
XFS_STATS_ADD(xs_read_bytes, ret);
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return ret;
}
ssize_t
nfs_file_splice_read(struct file *filp, loff_t *ppos,
struct pipe_inode_info *pipe, size_t count,
unsigned int flags)
{
struct inode *inode = file_inode(filp);
ssize_t res;
dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n",
filp, (unsigned long) count, (unsigned long long) *ppos);
res = nfs_revalidate_mapping_protected(inode, filp->f_mapping);
if (!res) {
res = generic_file_splice_read(filp, ppos, pipe, count, flags);
if (res > 0)
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
}
return res;
}
ssize_t
xfs_splice_read(
bhv_desc_t *bdp,
struct file *infilp,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t count,
int flags,
int ioflags,
cred_t *credp)
{
xfs_inode_t *ip = XFS_BHVTOI(bdp);
xfs_mount_t *mp = ip->i_mount;
ssize_t ret;
XFS_STATS_INC(xs_read_calls);
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
xfs_ilock(ip, XFS_IOLOCK_SHARED);
if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_READ) &&
(!(ioflags & IO_INVIS))) {
vrwlock_t locktype = VRWLOCK_READ;
int error;
error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
*ppos, count,
FILP_DELAY_FLAG(infilp), &locktype);
if (error) {
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return -error;
}
}
xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, &ip->i_iocore,
pipe, count, *ppos, ioflags);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
if (ret > 0)
XFS_STATS_ADD(xs_read_bytes, ret);
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return ret;
}
STATIC ssize_t
xfs_file_splice_read(
struct file *infilp,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t count,
unsigned int flags)
{
struct xfs_inode *ip = XFS_I(infilp->f_mapping->host);
int ioflags = 0;
ssize_t ret;
XFS_STATS_INC(ip->i_mount, xs_read_calls);
if (infilp->f_mode & FMODE_NOCMTIME)
ioflags |= XFS_IO_INVIS;
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
/*
* DAX inodes cannot ues the page cache for splice, so we have to push
* them through the VFS IO path. This means it goes through
* ->read_iter, which for us takes the XFS_IOLOCK_SHARED. Hence we
* cannot lock the splice operation at this level for DAX inodes.
*/
if (IS_DAX(VFS_I(ip))) {
ret = default_file_splice_read(infilp, ppos, pipe, count,
flags);
goto out;
}
xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
out:
if (ret > 0)
XFS_STATS_ADD(ip->i_mount, xs_read_bytes, ret);
return ret;
}
static ssize_t
smb_file_splice_read(struct file *file, loff_t *ppos,
struct pipe_inode_info *pipe, size_t count,
unsigned int flags)
{
struct dentry *dentry = file->f_path.dentry;
ssize_t status;
VERBOSE("file %s/%s, pos=%Ld, count=%lu\n",
DENTRY_PATH(dentry), *ppos, count);
status = smb_revalidate_inode(dentry);
if (status) {
PARANOIA("%s/%s validation failed, error=%Zd\n",
DENTRY_PATH(dentry), status);
goto out;
}
status = generic_file_splice_read(file, ppos, pipe, count, flags);
out:
return status;
}
ssize_t
xfs_splice_read(
xfs_inode_t *ip,
struct file *infilp,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t count,
int flags,
int ioflags)
{
xfs_mount_t *mp = ip->i_mount;
ssize_t ret;
XFS_STATS_INC(xs_read_calls);
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
xfs_ilock(ip, XFS_IOLOCK_SHARED);
if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
int iolock = XFS_IOLOCK_SHARED;
int error;
error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, *ppos, count,
FILP_DELAY_FLAG(infilp), &iolock);
if (error) {
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return -error;
}
}
xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, ip,
pipe, count, *ppos, ioflags);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
if (ret > 0)
XFS_STATS_ADD(xs_read_bytes, ret);
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
return ret;
}
static int vvp_io_read_start(const struct lu_env *env,
const struct cl_io_slice *ios)
{
struct vvp_io *vio = cl2vvp_io(env, ios);
struct ccc_io *cio = cl2ccc_io(env, ios);
struct cl_io *io = ios->cis_io;
struct cl_object *obj = io->ci_obj;
struct inode *inode = ccc_object_inode(obj);
struct ll_ra_read *bead = &vio->cui_bead;
struct file *file = cio->cui_fd->fd_file;
int result;
loff_t pos = io->u.ci_rd.rd.crw_pos;
long cnt = io->u.ci_rd.rd.crw_count;
long tot = cio->cui_tot_count;
int exceed = 0;
CLOBINVRNT(env, obj, ccc_object_invariant(obj));
CDEBUG(D_VFSTRACE, "read: -> [%lli, %lli)\n", pos, pos + cnt);
if (!can_populate_pages(env, io, inode))
return 0;
result = ccc_prep_size(env, obj, io, pos, tot, &exceed);
if (result != 0)
return result;
else if (exceed != 0)
goto out;
LU_OBJECT_HEADER(D_INODE, env, &obj->co_lu,
"Read ino %lu, %lu bytes, offset %lld, size %llu\n",
inode->i_ino, cnt, pos, i_size_read(inode));
/* turn off the kernel's read-ahead */
cio->cui_fd->fd_file->f_ra.ra_pages = 0;
/* initialize read-ahead window once per syscall */
if (!vio->cui_ra_window_set) {
vio->cui_ra_window_set = 1;
bead->lrr_start = cl_index(obj, pos);
bead->lrr_count = cl_index(obj, tot + PAGE_CACHE_SIZE - 1);
ll_ra_read_in(file, bead);
}
/* BUG: 5972 */
file_accessed(file);
switch (vio->cui_io_subtype) {
case IO_NORMAL:
result = lustre_generic_file_read(file, cio, &pos);
break;
case IO_SPLICE:
result = generic_file_splice_read(file, &pos,
vio->u.splice.cui_pipe, cnt,
vio->u.splice.cui_flags);
/* LU-1109: do splice read stripe by stripe otherwise if it
* may make nfsd stuck if this read occupied all internal pipe
* buffers. */
io->ci_continue = 0;
break;
default:
CERROR("Wrong IO type %u\n", vio->cui_io_subtype);
LBUG();
}
out:
if (result >= 0) {
if (result < cnt)
io->ci_continue = 0;
io->ci_nob += result;
ll_rw_stats_tally(ll_i2sbi(inode), current->pid, cio->cui_fd,
pos, result, READ);
result = 0;
}
return result;
}
ssize_t sjfs_fops_splice_read(struct file *f, loff_t *l, struct pipe_inode_info *p, size_t s, unsigned int ui) {
printk("sjfs_fops_splice_read -> generic_file_splice_read\n");
return generic_file_splice_read(f, l, p, s, ui);
}
int
xixfs_sync_inode(struct inode *inode)
{
struct writeback_control wbc = {
.sync_mode = WB_SYNC_ALL,
.nr_to_write = 0, /* sys_fsync did this */
};
return sync_inode(inode, &wbc);
}
#endif
int
xixfs_sync_file(
struct file *file,
struct dentry *dentry,
int datasync
)
{
struct inode *inode = dentry->d_inode;
PXIXFS_LINUX_FCB pFCB = NULL;
PXIXFS_LINUX_VCB pVCB = NULL;
int err = 0;
int ret = 0;
XIXCORE_ASSERT(inode);
pVCB = XIXFS_SB(inode->i_sb);
XIXFS_ASSERT_VCB(pVCB);
pFCB = XIXFS_I(inode);
XIXFS_ASSERT_FCB(pFCB);
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("ENTER xixfs_sync_file (%s).\n", file->f_dentry->d_name.name));
if(pVCB->XixcoreVcb.IsVolumeWriteProtected){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR xixfs_sync_file : is read only .\n"));
return -EPERM;
}
if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR DELETED FILE \n"));
return -EPERM;
}
XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE);
if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) {
#if LINUX_VERSION_25_ABOVE
ret = sync_mapping_buffers(inode->i_mapping);
if (!(inode->i_state & I_DIRTY))
return ret;
if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
return ret;
xixfs_sync_inode(inode);
#endif
if(XIXCORE_TEST_FLAGS(pFCB->XixcoreFcb.FCBFlags,XIXCORE_FCB_MODIFIED_FILE)){
#if LINUX_VERSION_25_ABOVE
err = xixfs_write_inode(inode, 1);
#else
xixfs_write_inode(inode, 1);
#endif
if(pFCB->XixcoreFcb.WriteStartOffset != -1){
printk(KERN_DEBUG "Set Update Information!!!\n");
xixfs_SendFileChangeRC(
pVCB->XixcoreVcb.HostMac,
pFCB->XixcoreFcb.LotNumber,
pVCB->XixcoreVcb.VolumeId,
i_size_read(inode),
pFCB->XixcoreFcb.RealAllocationSize,
pFCB->XixcoreFcb.WriteStartOffset
);
pFCB->XixcoreFcb.WriteStartOffset = -1;
}
if (ret == 0)
ret = err;
return ret;
}
}else {
return -EPERM;
}
return ret;
}
#if LINUX_VERSION_25_ABOVE
#if LINUX_VERSION_2_6_19_REPLACE_INTERFACE
ssize_t
xixfs_file_splice_read(
struct file *in,
loff_t *ppos,
struct pipe_inode_info *pipe,
size_t len,
unsigned int flags
)
{
return generic_file_splice_read(in, ppos, pipe, len, flags);
}
ssize_t
xixfs_file_splice_write(
struct pipe_inode_info *pipe,
struct file *out,
loff_t *ppos,
size_t len,
unsigned int flags
)
{
ssize_t RC = 0;
int64 index = 0;
struct address_space *mapping = out->f_mapping;
struct inode *inode = mapping->host;
PXIXFS_LINUX_FCB pFCB = NULL;
PXIXFS_LINUX_VCB pVCB = NULL;
XIXCORE_ASSERT(inode);
pVCB = XIXFS_SB(inode->i_sb);
XIXFS_ASSERT_VCB(pVCB);
pFCB = XIXFS_I(inode);
XIXFS_ASSERT_FCB(pFCB);
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("ENTER xixfs_file_splice_write (%s).\n", out->f_dentry->d_name.name));
if(pVCB->XixcoreVcb.IsVolumeWriteProtected){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR xixfs_file_splice_write : is read only .\n"));
return -EPERM;
}
if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR DELETED FILE \n"));
return -EPERM;
}
XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE);
if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) {
index =(int64) (*ppos);
RC = generic_file_splice_write(pipe, out, ppos, len, flags);
if(RC > 0 ) {
if(pFCB->XixcoreFcb.WriteStartOffset == -1) {
pFCB->XixcoreFcb.WriteStartOffset = index;
XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE);
}
if(pFCB->XixcoreFcb.WriteStartOffset > index ){
pFCB->XixcoreFcb.WriteStartOffset = index;
XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE);
}
}
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("EXIT xixfs_file_writev (%d).\n", RC));
return RC;
}
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("EXIT xixfs_file_writev ERROR.\n"));
return -EPERM;
}
