/* * 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; }