/*
* Write to a file (through the page cache).
*/
static ssize_t
nfs_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
struct dentry * dentry = file->f_dentry;
struct inode * inode = dentry->d_inode;
ssize_t result;
dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%lu)\n",
dentry->d_parent->d_name.name, dentry->d_name.name,
inode->i_ino, (unsigned long) count, (unsigned long) *ppos);
result = -EBUSY;
if (IS_SWAPFILE(inode))
goto out_swapfile;
result = nfs_revalidate_inode(NFS_DSERVER(dentry), dentry);
if (result)
goto out;
result = count;
if (!count)
goto out;
result = generic_file_write(file, buf, count, ppos);
out:
return result;
out_swapfile:
printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
goto out;
}
/*
* Write to a file (through the page cache).
*/
static ssize_t
smb_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
struct dentry * dentry = file->f_dentry;
ssize_t result;
VERBOSE("file %s/%s, count=%lu@%lu\n",
DENTRY_PATH(dentry),
(unsigned long) count, (unsigned long) *ppos);
result = smb_revalidate_inode(dentry);
if (result) {
PARANOIA("%s/%s validation failed, error=%Zd\n",
DENTRY_PATH(dentry), result);
goto out;
}
result = smb_open(dentry, SMB_O_WRONLY);
if (result)
goto out;
if (count > 0) {
result = generic_file_write(file, buf, count, ppos);
VERBOSE("pos=%ld, size=%ld, mtime=%ld, atime=%ld\n",
(long) file->f_pos, (long) dentry->d_inode->i_size,
dentry->d_inode->i_mtime, dentry->d_inode->i_atime);
}
out:
return result;
}
static ssize_t
HgfsWrite(struct file *file, // IN: File to write to
const char __user *buf, // IN: User buffer where the data is
size_t count, // IN: Number of bytes to write
loff_t *offset) // IN: Offset to begin writing at
{
int result;
ASSERT(file);
ASSERT(file->f_dentry);
ASSERT(file->f_dentry->d_inode);
ASSERT(buf);
ASSERT(offset);
LOG(6, (KERN_DEBUG "VMware hgfs: HgfsWrite: write %Zu bytes to fh %u "
"at offset %Lu\n", count, FILE_GET_FI_P(file)->handle, *offset));
result = HgfsRevalidate(file->f_dentry);
if (result) {
LOG(4, (KERN_DEBUG "VMware hgfs: HgfsWrite: invalid dentry\n"));
goto out;
}
result = generic_file_write(file, buf, count, offset);
out:
return result;
}
static ssize_t hpfs_file_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
ssize_t retval;
retval = generic_file_write(file, buf, count, ppos);
if (retval > 0)
hpfs_i(file->f_dentry->d_inode)->i_dirty = 1;
return retval;
}
static ssize_t
cifs_write_wrapper(struct file * file, const char __user *write_data,
size_t write_size, loff_t * poffset)
{
ssize_t written;
if(file->f_dentry == NULL)
return -EIO;
else if(file->f_dentry->d_inode == NULL)
return -EIO;
cFYI(1,("In write_wrapper size %zd at %lld",write_size,*poffset));
written = generic_file_write(file,write_data,write_size,poffset);
if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll) {
if(file->f_dentry->d_inode->i_mapping) {
filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
}
}
return written;
}
static ssize_t
cifs_write_wrapper(struct file * file, const char __user *write_data,
size_t write_size, loff_t * poffset)
{
ssize_t written;
if(file == NULL)
return -EIO;
else if(file->f_dentry == NULL)
return -EIO;
else if(file->f_dentry->d_inode == NULL)
return -EIO;
cFYI(1,("In write_wrapper size %zd at %lld",write_size,*poffset));
#ifdef CONFIG_CIFS_EXPERIMENTAL /* BB fixme - fix user char * to kernel char * mapping here BB */
/* check whether we can cache writes locally */
if(file->f_dentry->d_sb) {
struct cifs_sb_info *cifs_sb;
cifs_sb = CIFS_SB(file->f_dentry->d_sb);
if(cifs_sb != NULL) {
if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
return cifs_user_write(file,write_data,
write_size,poffset);
}
}
}
#endif /* CIFS_EXPERIMENTAL */
written = generic_file_write(file,write_data,write_size,poffset);
if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll) {
if(file->f_dentry->d_inode->i_mapping) {
filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
}
}
return written;
}
ssize_t
xixfs_file_write(
struct file *file,
const char __user *buf,
size_t count,
loff_t *ppos
)
{
ssize_t RC = 0;
int64 index = 0;
#if LINUX_VERSION_25_ABOVE
struct address_space *mapping = file->f_mapping;
#else
struct address_space *mapping = file->f_dentry->d_inode->i_mapping;
#endif
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_TRACE, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("ENTER xixfs_file_write (%s).\n", file->f_dentry->d_name.name));
if(pVCB->XixcoreVcb.IsVolumeWriteProtected){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR xixfs_file_write : is read only .\n"));
return -EPERM;
}
XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE);
if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("ERROR DELETED FILE \n"));
return -EPERM;
}
if( pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) {
index =(int64) (*ppos);
#if LINUX_VERSION_2_6_19_REPLACE_INTERFACE
RC = do_sync_write(file, buf, count, ppos);
#else
RC = generic_file_write(file, buf, count, ppos);
#endif
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);
}
}
return RC;
} else {
return -EPERM;
}
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT),
("EXIT xixfs_file_write .\n"));
return RC;
}
