cifs: clean up management of open filehandles
Subsystems (2)
cover cifs: clean up management of open filehandles
This patchset fixes a number of problems with the existing CIFS code. It eliminates the backreference to the filp from cifsFileInfo, allowing a cifsFileInfo to outlive the filp that it was generated against.
With that change, most of the closing of a filehandle on the server is moved to cifsFileInfo_put. cifs_close is then changed to just put the filehandle instead of trying to wait around for existing users to finish with it.
With this change, there is some further cleanup that can be done as well. For instance, there's no real need to continually search for new filehandles in cifs_writepages now that we hold a reference to one. I'll hold back on that until I know how this set has been received.
This set is an ordered set and should not be committed out of order. It should be bisectable. I've tested the resulting set and it seems to work fine.
Jeff Layton (14):
cifs: keep dentry reference in cifsFileInfo instead of inode
reference
cifs: don't use vfsmount to pin superblock for oplock breaks
cifs: eliminate cifs_posix_open_inode_helper
cifs: eliminate oflags option from cifs_new_fileinfo
cifs: eliminate the inode argument from cifs_new_fileinfo
cifs: clean up cifs_reopen_file
cifs: cifs_write argument change and cleanup
cifs: eliminate pfile pointer from cifsFileInfo
cifs: move cifs_new_fileinfo to file.c
cifs: convert GlobalSMBSeslock from a rwlock to regular spinlock
cifs: move cifsFileInfo_put to file.c
cifs: move close processing from cifs_close to cifsFileInfo_put
cifs: wait for writeback to complete in cifs_flush
cifs: eliminate cifsInodeInfo->write_behind_rc
fs/cifs/cifs_fs_sb.h | 1 + fs/cifs/cifsfs.c | 21 ++- fs/cifs/cifsfs.h | 6 +- fs/cifs/cifsglob.h | 19 +-- fs/cifs/cifsproto.h | 6 +- fs/cifs/cifssmb.c | 4 +- fs/cifs/dir.c | 60 +----- fs/cifs/file.c | 574 +++++++++++++++++++------------------------------- fs/cifs/inode.c | 15 +- fs/cifs/misc.c | 18 +-- fs/cifs/readdir.c | 6 +- 11 files changed, 260 insertions(+), 470 deletions(-)
Signature · 1 line
1.7.2.3
A message that is not in the archive (sent off-list or not yet received): 1286214781-626-1-git-send-email-jlayton-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org
PATCH 1/14 cifs: keep dentry reference in cifsFileInfo instead of inode reference
cifsFileInfo is a bit problematic. It contains a reference back to the struct file itself. This makes it difficult for a cifsFileInfo to exist without a corresponding struct file.
It would be better instead of the cifsFileInfo just held info pertaining to the open file on the server instead without any back refrences to the struct file. This would allow it to exist after the filp to which it was originally attached was closed.
Much of the use of the file pointer in this struct is to get at the dentry. Begin divorcing the cifsFileInfo from the struct file by keeping a reference to the dentry. Since the dentry will have a reference to the inode, we can eliminate the "pInode" field too and convert the igrab/iput to dget/dput.
--- fs/cifs/cifsglob.h | 4 ++-- fs/cifs/dir.c | 3 ++- fs/cifs/file.c | 2 +- fs/cifs/misc.c | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-)
fs/cifs/cifsglob.h +2 -2
@@ -387,7 +387,7 @@ struct cifsFileInfo {/* BB add lock scope info here if needed */ ;/* lock scope id (0 if none) */ struct file *pfile;/* needed for writepage */ -struct inode *pInode;/* needed for oplock break */ +struct dentry *dentry;struct vfsmount *mnt;struct tcon_link *tlink;struct mutex lock_mutex;
@@ -412,7 +412,7 @@ static inline void cifsFileInfo_put(struct cifsFileInfo *cifs_file) {if (atomic_dec_and_test (&cifs_file->count)) {cifs_put_tlink (cifs_file->tlink); -iput (cifs_file->pInode); +dput (cifs_file->dentry);kfree (cifs_file); } }
fs/cifs/dir.c +2 -1
@@ -135,6 +135,7 @@ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle, struct file *file, struct vfsmount *mnt, struct tcon_link *tlink, unsigned int oflags, __u32 oplock) { + struct dentry *dentry = file->f_path.dentry;struct cifsFileInfo *pCifsFile;struct cifsInodeInfo *pCifsInode;
@@ -145,7 +146,7 @@ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle, struct file *file, pCifsFile->netfid = fileHandle; pCifsFile->pid = current->tgid; pCifsFile->uid =current_fsuid (); - pCifsFile->pInode =igrab (newinode); + pCifsFile->dentry =dget (dentry); pCifsFile->mnt = mnt; pCifsFile->pfile = file; pCifsFile->invalidHandle = false;
fs/cifs/file.c +1 -1
@@ -2335,7 +2335,7 @@ void cifs_oplock_break(struct work_struct *work) { struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo, oplock_break); -struct inode *inode = cfile->pInode; +struct inode *inode = cfile->dentry->d_inode;struct cifsInodeInfo *cinode =CIFS_I (inode);int rc, waitrc =0 ;
fs/cifs/misc.c +1 -1
@@ -578,7 +578,7 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv) }cFYI (1 ,"file id match, oplock break" ); - pCifsInode =CIFS_I (netfile->pInode); + pCifsInode =CIFS_I (netfile->dentry->d_inode); pCifsInode->clientCanCacheAll = false;if (pSMB->OplockLevel ==0 ) pCifsInode->clientCanCacheRead = false;
Signature · 1 line
1.7.2.3
PATCH 2/14 cifs: don't use vfsmount to pin superblock for oplock breaks
In reply to a message not in the archiveFilesystems aren't really supposed to do anything with a vfsmount. It's considered a layering violation since vfsmounts are entirely managed at the VFS layer.
CIFS currently keeps an active reference to a vfsmount in order to prevent the superblock vanishing before an oplock break has completed. What we really want to do instead is to keep sb->s_active high until the oplock break has completed. This patch borrows the scheme that NFS uses for handling sillyrenames.
An atomic_t is added to the cifs_sb_info. When it transitions from 0 to 1, an extra reference to the superblock is taken (by bumping the s_active value). When it transitions from 1 to 0, that reference is dropped and a the superblock teardown may proceed if there are no more references to it.
Also, the vfsmount pointer is removed from cifsFileInfo and from cifs_new_fileinfo, and some bogus forward declarations are removed from cifsfs.h.
--- fs/cifs/cifs_fs_sb.h | 1 + fs/cifs/cifsfs.c | 18 ++++++++++++++++++ fs/cifs/cifsfs.h | 6 ++---- fs/cifs/cifsglob.h | 1 - fs/cifs/cifsproto.h | 2 +- fs/cifs/dir.c | 10 +++------- fs/cifs/file.c | 9 ++++----- 7 files changed, 29 insertions(+), 18 deletions(-)
fs/cifs/cifs_fs_sb.h +1 -0
@@ -48,6 +48,7 @@ struct cifs_sb_info {struct nls_table *local_nls;unsigned int rsize;unsigned int wsize; +atomic_t active;uid_t mnt_uid;gid_t mnt_gid;mode_t mnt_file_mode;
fs/cifs/cifsfs.c +18 -0
@@ -83,6 +83,24 @@ extern mempool_t *cifs_sm_req_poolp;extern mempool_t *cifs_req_poolp;extern mempool_t *cifs_mid_poolp; +void +cifs_sb_active (struct super_block *sb) +{ +struct cifs_sb_info *server =CIFS_SB (sb); + +if (atomic_inc_return (&server->active) ==1 ) +atomic_inc (&sb->s_active); +} + +void +cifs_sb_deactive (struct super_block *sb) +{ +struct cifs_sb_info *server =CIFS_SB (sb); + +if (atomic_dec_and_test (&server->active)) +deactivate_super (sb); +} +static int cifs_read_super (struct super_block *sb,void *data,const char *devname,int silent)
fs/cifs/cifsfs.h +2 -4
@@ -42,10 +42,8 @@ extern const struct address_space_operations cifs_addr_ops;extern const struct address_space_operations cifs_addr_ops_smallbuf;/* Functions related to super block operations */ -/* extern const struct super_operations cifs_super_ops;*/ -extern void cifs_read_inode (struct inode *); -/*extern void cifs_delete_inode(struct inode *);*/ /* BB not needed yet */ -/* extern void cifs_write_inode(struct inode *); */ /* BB not needed yet */ +extern void cifs_sb_active (struct super_block *sb); +extern void cifs_sb_deactive (struct super_block *sb);/* Functions related to inodes */ extern const struct inode_operations cifs_dir_inode_ops;
fs/cifs/cifsglob.h +0 -1
@@ -388,7 +388,6 @@ struct cifsFileInfo {/* lock scope id (0 if none) */ struct file *pfile;/* needed for writepage */ struct dentry *dentry; -struct vfsmount *mnt;struct tcon_link *tlink;struct mutex lock_mutex;struct list_head llist;/* list of byte range locks we have. */
fs/cifs/cifsproto.h +1 -1
@@ -107,7 +107,7 @@ extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,extern struct cifsFileInfo *cifs_new_fileinfo (struct inode *newinode,__u16 fileHandle,struct file *file, -struct vfsmount *mnt,struct tcon_link *tlink, +struct tcon_link *tlink,unsigned int oflags,__u32 oplock); extern int cifs_posix_open(char *full_path, struct inode **pinode, struct super_block *sb,
fs/cifs/dir.c +3 -7
@@ -132,8 +132,7 @@ cifs_bp_rename_retry:struct cifsFileInfo *cifs_new_fileinfo (struct inode *newinode,__u16 fileHandle,struct file *file, -struct vfsmount *mnt,struct tcon_link *tlink, -unsigned int oflags,__u32 oplock) +struct tcon_link *tlink,unsigned int oflags,__u32 oplock) {struct dentry *dentry = file->f_path.dentry;struct cifsFileInfo *pCifsFile;
@@ -147,7 +146,6 @@ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle, struct file *file, pCifsFile->pid = current->tgid; pCifsFile->uid =current_fsuid (); pCifsFile->dentry =dget (dentry); - pCifsFile->mnt = mnt; pCifsFile->pfile = file; pCifsFile->invalidHandle = false; pCifsFile->closePend = false;
@@ -485,8 +483,7 @@ cifs_create_set_dentry: } pfile_info =cifs_new_fileinfo (newinode, fileHandle, filp, - nd->path.mnt, tlink, oflags, - oplock); + tlink, oflags, oplock);if (pfile_info ==NULL ) {fput (filp);CIFSSMBClose (xid, tcon, fileHandle);
@@ -760,8 +757,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry, } cfile =cifs_new_fileinfo (newInode, fileHandle, filp, - nd->path.mnt, tlink, - nd->intent.open.flags, + tlink, nd->intent.open.flags, oplock);if (cfile ==NULL ) {fput (filp);
fs/cifs/file.c +4 -5
@@ -282,7 +282,6 @@ int cifs_open(struct inode *inode, struct file *file) } pCifsFile =cifs_new_fileinfo (inode, netfid, file, - file->f_path.mnt, tlink, oflags, oplock);if (pCifsFile ==NULL ) {CIFSSMBClose (xid, tcon, netfid);
@@ -375,8 +374,8 @@ int cifs_open(struct inode *inode, struct file *file)if (rc !=0 ) goto out; - pCifsFile =cifs_new_fileinfo (inode, netfid, file, file->f_path.mnt, - tlink, file->f_flags, oplock); + pCifsFile =cifs_new_fileinfo (inode, netfid, file, tlink, + file->f_flags, oplock);if (pCifsFile ==NULL ) { rc = -ENOMEM ; goto out;
@@ -2381,13 +2380,13 @@ void cifs_oplock_break(struct work_struct *work)void cifs_oplock_break_get (struct cifsFileInfo *cfile) { -mntget (cfile->mnt);cifsFileInfo_get (cfile); +cifs_sb_active (cfile->dentry->d_sb); }void cifs_oplock_break_put (struct cifsFileInfo *cfile) { -mntput (cfile->mnt); +cifs_sb_deactive (cfile->dentry->d_sb);cifsFileInfo_put (cfile); }
Signature · 1 line
1.7.2.3
PATCH 3/14 cifs: eliminate cifs_posix_open_inode_helper
In reply to a message not in the archiveThis function is redundant. The only thing it does is set the canCache flags, but those get set in cifs_new_fileinfo anyway.
--- fs/cifs/file.c | 67 -------------------------------------------------------- 1 files changed, 0 insertions(+), 67 deletions(-)
fs/cifs/file.c +0 -67
@@ -106,64 +106,6 @@ static inline int cifs_get_disposition(unsigned int flags)return FILE_OPEN ; } -/* all arguments to this function must be checked for validity in caller */ -static inline int -cifs_posix_open_inode_helper (struct inode *inode,struct file *file, -struct cifsInodeInfo *pCifsInode,__u32 oplock, -u16 netfid) -{ - -write_lock (&GlobalSMBSeslock); - - pCifsInode =CIFS_I (file->f_path.dentry->d_inode); -if (pCifsInode ==NULL ) { -write_unlock (&GlobalSMBSeslock); -return -EINVAL ; - } - -if (pCifsInode->clientCanCacheRead) { -/* we have the inode open somewhere else -no need to discard cache data */ - goto psx_client_can_cache; - } - -/* BB FIXME need to fix this check to move it earlier into posix_open -BB fIX following section BB FIXME */ - -/* if not oplocked, invalidate inode pages if mtime or file -size changed */ -/* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime)); -if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) && -(file->f_path.dentry->d_inode->i_size == -(loff_t)le64_to_cpu(buf->EndOfFile))) { -cFYI(1, "inode unchanged on server"); -} else { -if (file->f_path.dentry->d_inode->i_mapping) { -rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping); -if (rc != 0) -CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc; -} -cFYI(1, "invalidating remote inode since open detected it " -"changed"); -invalidate_remote_inode(file->f_path.dentry->d_inode); -} */ - -psx_client_can_cache: -if ((oplock &0xF ) ==OPLOCK_EXCLUSIVE ) { - pCifsInode->clientCanCacheAll = true; - pCifsInode->clientCanCacheRead = true; -cFYI (1 ,"Exclusive Oplock granted on inode %p" , - file->f_path.dentry->d_inode); - }else if ((oplock &0xF ) ==OPLOCK_READ ) - pCifsInode->clientCanCacheRead = true; - -/* will have to change the unlock if we reenable the -filemap_fdatawrite (which does not seem necessary */ -write_unlock (&GlobalSMBSeslock); -return 0 ; -} - -/* all arguments to this function must be checked for validity in caller */ static inline int cifs_open_inode_helper (struct inode *inode,struct cifsTconInfo *pTcon,__u32 oplock,FILE_ALL_INFO *buf,char *full_path,int xid)
@@ -271,15 +213,6 @@ int cifs_open(struct inode *inode, struct file *file) oflags, &oplock, &netfid, xid);if (rc ==0 ) {cFYI (1 ,"posix open succeeded" ); -/* no need for special case handling of setting mode -on read only files needed here */ - - rc =cifs_posix_open_inode_helper (inode, file, - pCifsInode, oplock, netfid); -if (rc !=0 ) { -CIFSSMBClose (xid, tcon, netfid); - goto out; - } pCifsFile =cifs_new_fileinfo (inode, netfid, file, tlink, oflags, oplock);
Signature · 1 line
1.7.2.3
PATCH 4/14 cifs: eliminate oflags option from cifs_new_fileinfo
In reply to a message not in the archiveEliminate the poor, misunderstood "oflags" option from cifs_new_fileinfo. The callers mostly pass in the filp->f_flags here, except for one place that passes in the flags after they've been converted to their SMB_O_* equivalents.
None of these are correct however since we're checking that value for the presence of FMODE_READ. Luckily that only affects how the f_list is ordered.
What we really want here is the file->f_mode. Since we pass in a file pointer already anyway, just use the f_mode there for this purpose.
--- fs/cifs/cifsproto.h | 3 +-- fs/cifs/dir.c | 9 ++++----- fs/cifs/file.c | 5 ++--- 3 files changed, 7 insertions(+), 10 deletions(-)
fs/cifs/cifsproto.h +1 -2
@@ -107,8 +107,7 @@ extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,extern struct cifsFileInfo *cifs_new_fileinfo (struct inode *newinode,__u16 fileHandle,struct file *file, -struct tcon_link *tlink, -unsigned int oflags,__u32 oplock); +struct tcon_link *tlink,__u32 oplock); extern int cifs_posix_open(char *full_path, struct inode **pinode, struct super_block *sb, int mode, int oflags,
fs/cifs/dir.c +4 -5
@@ -132,7 +132,7 @@ cifs_bp_rename_retry:struct cifsFileInfo *cifs_new_fileinfo (struct inode *newinode,__u16 fileHandle,struct file *file, -struct tcon_link *tlink,unsigned int oflags,__u32 oplock) +struct tcon_link *tlink,__u32 oplock) {struct dentry *dentry = file->f_path.dentry;struct cifsFileInfo *pCifsFile;
@@ -161,7 +161,7 @@ cifs_new_fileinfo(struct inode *newinode, __u16 fileHandle, struct file *file, pCifsInode =CIFS_I (newinode);if (pCifsInode) {/* if readable file instance put first in list*/ -if (oflags &FMODE_READ ) +if (file->f_mode &FMODE_READ )list_add (&pCifsFile->flist, &pCifsInode->openFileList);else list_add_tail(&pCifsFile->flist,
@@ -483,7 +483,7 @@ cifs_create_set_dentry: } pfile_info =cifs_new_fileinfo (newinode, fileHandle, filp, - tlink, oflags, oplock); + tlink, oplock);if (pfile_info ==NULL ) {fput (filp);CIFSSMBClose (xid, tcon, fileHandle);
@@ -757,8 +757,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry, } cfile =cifs_new_fileinfo (newInode, fileHandle, filp, - tlink, nd->intent.open.flags, - oplock); + tlink, oplock);if (cfile ==NULL ) {fput (filp);CIFSSMBClose (xid, pTcon, fileHandle);
fs/cifs/file.c +2 -3
@@ -215,7 +215,7 @@ int cifs_open(struct inode *inode, struct file *file)cFYI (1 ,"posix open succeeded" ); pCifsFile =cifs_new_fileinfo (inode, netfid, file, - tlink, oflags, oplock); + tlink, oplock);if (pCifsFile ==NULL ) {CIFSSMBClose (xid, tcon, netfid); rc = -ENOMEM ;
@@ -307,8 +307,7 @@ int cifs_open(struct inode *inode, struct file *file)if (rc !=0 ) goto out; - pCifsFile =cifs_new_fileinfo (inode, netfid, file, tlink, - file->f_flags, oplock); + pCifsFile =cifs_new_fileinfo (inode, netfid, file, tlink, oplock);if (pCifsFile ==NULL ) { rc = -ENOMEM ; goto out;
Signature · 1 line
1.7.2.3
PATCH 5/14 cifs: eliminate the inode argument from cifs_new_fileinfo
In reply to a message not in the archiveIt already takes a file pointer. The inode associated with that had damn well better be the same one we're passing in anyway. Thus, there's no need for a separate argument here.
Also, get rid of the bogus check for a null pCifsInode pointer. The CIFS_I macro uses container_of(), and that will virtually never return a NULL pointer anyway.
--- fs/cifs/cifsproto.h | 3 +-- fs/cifs/dir.c | 42 ++++++++++++++++++++---------------------- fs/cifs/file.c | 6 +++--- 3 files changed, 24 insertions(+), 27 deletions(-)
fs/cifs/cifsproto.h +1 -2
@@ -105,8 +105,7 @@ extern u64 cifs_UnixTimeToNT(struct timespec);extern struct timespec cnvrtDosUnixTm (__le16 le_date,__le16 le_time,int offset); -extern struct cifsFileInfo *cifs_new_fileinfo (struct inode *newinode, -__u16 fileHandle,struct file *file, +extern struct cifsFileInfo *cifs_new_fileinfo (__u16 fileHandle,struct file *file,struct tcon_link *tlink,__u32 oplock); extern int cifs_posix_open(char *full_path, struct inode **pinode, struct super_block *sb,
fs/cifs/dir.c +20 -22
70 lines not on this page · raw message
fs/cifs/file.c +3 -3
@@ -214,8 +214,8 @@ int cifs_open(struct inode *inode, struct file *file)if (rc ==0 ) {cFYI (1 ,"posix open succeeded" ); - pCifsFile =cifs_new_fileinfo (inode, netfid, file, - tlink, oplock); + pCifsFile =cifs_new_fileinfo (netfid, file, tlink, + oplock);if (pCifsFile ==NULL ) {CIFSSMBClose (xid, tcon, netfid); rc = -ENOMEM ;
@@ -307,7 +307,7 @@ int cifs_open(struct inode *inode, struct file *file)if (rc !=0 ) goto out; - pCifsFile =cifs_new_fileinfo (inode, netfid, file, tlink, oplock); + pCifsFile =cifs_new_fileinfo (netfid, file, tlink, oplock);if (pCifsFile ==NULL ) { rc = -ENOMEM ; goto out;
Signature · 1 line
1.7.2.3
PATCH 6/14 cifs: clean up cifs_reopen_file
In reply to a message not in the archiveAdd a f_flags field that holds the f_flags field from the filp. We'll need this info in case the filp ever goes away before the cifsFileInfo does. Have cifs_reopen_file use that value instead of filp->f_flags too and have it take a cifsFileInfo arg instead of a filp.
While we're at it, get rid of some bogus cargo-cult NULL pointer checks in that function and reduce the level of indentation.
--- fs/cifs/cifsglob.h | 1 + fs/cifs/dir.c | 1 + fs/cifs/file.c | 128 ++++++++++++++++++++++----------------------------- 3 files changed, 57 insertions(+), 73 deletions(-)
fs/cifs/cifsglob.h +1 -0
@@ -388,6 +388,7 @@ struct cifsFileInfo {/* lock scope id (0 if none) */ struct file *pfile;/* needed for writepage */ struct dentry *dentry; +unsigned int f_flags;struct tcon_link *tlink;struct mutex lock_mutex;struct list_head llist;/* list of byte range locks we have. */
fs/cifs/dir.c +1 -0
@@ -147,6 +147,7 @@ cifs_new_fileinfo(__u16 fileHandle, struct file *file, pCifsFile->pid = current->tgid; pCifsFile->uid =current_fsuid (); pCifsFile->dentry =dget (dentry); + pCifsFile->f_flags = file->f_flags; pCifsFile->pfile = file; pCifsFile->invalidHandle = false; pCifsFile->closePend = false;
fs/cifs/file.c +55 -73
223 lines not on this page · raw message
Signature · 1 line
1.7.2.3
PATCH 7/14 cifs: cifs_write argument change and cleanup
In reply to a message not in the archiveHave cifs_write take a cifsFileInfo pointer instead of a filp. Since cifsFileInfo holds references on the dentry, and that holds one to the inode, we can eliminate some unneeded NULL pointer checks.
--- fs/cifs/file.c | 51 +++++++++++++++++---------------------------------- 1 files changed, 17 insertions(+), 34 deletions(-)
fs/cifs/file.c +17 -34
@@ -965,8 +965,9 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,return total_written; } -static ssize_t cifs_write (struct file *file,const char *write_data, -size_t write_size,loff_t *poffset) +static ssize_t cifs_write (struct cifsFileInfo *open_file, +const char *write_data,size_t write_size, +loff_t *poffset) {int rc =0 ;unsigned int bytes_written =0 ;
@@ -974,17 +975,14 @@ static ssize_t cifs_write(struct file *file, const char *write_data,struct cifs_sb_info *cifs_sb;struct cifsTconInfo *pTcon;int xid, long_op; -struct cifsFileInfo *open_file; -struct cifsInodeInfo *cifsi =CIFS_I (file->f_path.dentry->d_inode); +struct dentry *dentry = open_file->dentry; +struct cifsInodeInfo *cifsi =CIFS_I (dentry->d_inode); - cifs_sb =CIFS_SB (file->f_path.dentry->d_sb); + cifs_sb =CIFS_SB (dentry->d_sb);cFYI (1 ,"write %zd bytes to offset %lld of %s" , write_size, - *poffset, file->f_path.dentry->d_name.name); + *poffset, dentry->d_name.name); -if (file->private_data ==NULL ) -return -EBADF ; - open_file = file->private_data; pTcon =tlink_tcon (open_file->tlink); xid =GetXid ();
@@ -994,15 +992,6 @@ static ssize_t cifs_write(struct file *file, const char *write_data, total_written += bytes_written) { rc = -EAGAIN ;while (rc == -EAGAIN ) { -if (file->private_data ==NULL ) { -/* file has been closed on us */ -FreeXid (xid); -/* if we have gotten here we have written some data -and blocked, and the file has been freed on us -while we blocked so return what we managed to -write */ -return total_written; - }if (open_file->closePend) {FreeXid (xid);if (total_written)
@@ -1062,20 +1051,13 @@ static ssize_t cifs_write(struct file *file, const char *write_data,cifs_stats_bytes_written (pTcon, total_written); -/* since the write may have blocked check these pointers again */ -if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) { -/*BB We could make this contingent on superblock ATIME flag too */ -/* file->f_path.dentry->d_inode->i_ctime = -file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/ -if (total_written >0 ) { -spin_lock (&file->f_path.dentry->d_inode->i_lock); -if (*poffset > file->f_path.dentry->d_inode->i_size) -i_size_write (file->f_path.dentry->d_inode, - *poffset); -spin_unlock (&file->f_path.dentry->d_inode->i_lock); - } -mark_inode_dirty_sync (file->f_path.dentry->d_inode); +if (total_written >0 ) { +spin_lock (&dentry->d_inode->i_lock); +if (*poffset > dentry->d_inode->i_size) +i_size_write (dentry->d_inode, *poffset); +spin_unlock (&dentry->d_inode->i_lock); } +mark_inode_dirty_sync (dentry->d_inode);FreeXid (xid);return total_written; }
@@ -1246,8 +1228,8 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to) open_file =find_writable_file (CIFS_I (mapping->host), false);if (open_file) { - bytes_written =cifs_write (open_file->pfile, write_data, - to-from, &offset); + bytes_written =cifs_write (open_file, write_data, + to - from, &offset);cifsFileInfo_put (open_file);/* Does mm or vfs already set times? */ inode->i_atime = inode->i_mtime =current_fs_time (inode->i_sb);
@@ -1562,7 +1544,8 @@ static int cifs_write_end(struct file *file, struct address_space *mapping,/* BB check if anything else missing out of ppw such as updating last write time */ page_data =kmap (page); - rc =cifs_write (file, page_data + offset, copied, &pos); + rc =cifs_write (file->private_data, page_data + offset, + copied, &pos);/* if (rc < 0) should we set writebehind rc? */ kunmap (page);
Signature · 1 line
1.7.2.3
PATCH 8/14 cifs: eliminate pfile pointer from cifsFileInfo
In reply to a message not in the archiveAll the remaining users of cifsFileInfo->pfile just use it to get at the f_flags/f_mode. Now that we store that separately in the cifsFileInfo, there's no need to consult the pfile at all from a cifsFileInfo pointer.
--- fs/cifs/cifsglob.h | 1 - fs/cifs/dir.c | 1 - fs/cifs/file.c | 11 +++-------- 3 files changed, 3 insertions(+), 10 deletions(-)
fs/cifs/cifsglob.h +0 -1
@@ -386,7 +386,6 @@ struct cifsFileInfo {__u16 netfid;/* file id from remote */ /* BB add lock scope info here if needed */ ;/* lock scope id (0 if none) */ -struct file *pfile;/* needed for writepage */ struct dentry *dentry;unsigned int f_flags;struct tcon_link *tlink;
fs/cifs/dir.c +0 -1
@@ -148,7 +148,6 @@ cifs_new_fileinfo(__u16 fileHandle, struct file *file, pCifsFile->uid =current_fsuid (); pCifsFile->dentry =dget (dentry); pCifsFile->f_flags = file->f_flags; - pCifsFile->pfile = file; pCifsFile->invalidHandle = false; pCifsFile->closePend = false; pCifsFile->tlink =cifs_get_tlink (tlink);
fs/cifs/file.c +3 -8
@@ -1082,8 +1082,7 @@ struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,continue ;if (fsuid_only && open_file->uid !=current_fsuid ())continue ; -if (open_file->pfile && ((open_file->pfile->f_flags &O_RDWR ) || - (open_file->pfile->f_flags &O_RDONLY ))) { +if (OPEN_FMODE (open_file->f_flags) &FMODE_READ ) {if (!open_file->invalidHandle) {/* found a good file */ /* lock it so it will not be closed on us */
@@ -1132,9 +1131,7 @@ refind_writable:continue ;if (fsuid_only && open_file->uid !=current_fsuid ())continue ; -if (open_file->pfile && - ((open_file->pfile->f_flags &O_RDWR ) || - (open_file->pfile->f_flags &O_WRONLY ))) { +if (OPEN_FMODE (open_file->f_flags) &FMODE_WRITE ) {cifsFileInfo_get (open_file);if (!open_file->invalidHandle) {
@@ -2098,9 +2095,7 @@ static int is_inode_writable(struct cifsInodeInfo *cifs_inode)list_for_each_entry (open_file, &cifs_inode->openFileList, flist) {if (open_file->closePend)continue ; -if (open_file->pfile && - ((open_file->pfile->f_flags &O_RDWR ) || - (open_file->pfile->f_flags &O_WRONLY ))) { +if (OPEN_FMODE (open_file->f_flags) &FMODE_WRITE ) {read_unlock (&GlobalSMBSeslock);return 1 ; }
Signature · 1 line
1.7.2.3
PATCH 9/14 cifs: move cifs_new_fileinfo to file.c
In reply to a message not in the archiveIt's currently in dir.c which makes little sense...
--- fs/cifs/dir.c | 50 -------------------------------------------------- fs/cifs/file.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 50 deletions(-)
fs/cifs/dir.c +0 -50
@@ -130,56 +130,6 @@ cifs_bp_rename_retry:return full_path; } -struct cifsFileInfo * -cifs_new_fileinfo (__u16 fileHandle,struct file *file, -struct tcon_link *tlink,__u32 oplock) -{ -struct dentry *dentry = file->f_path.dentry; -struct inode *inode = dentry->d_inode; -struct cifsInodeInfo *pCifsInode =CIFS_I (inode); -struct cifsFileInfo *pCifsFile; - - pCifsFile =kzalloc (sizeof (struct cifsFileInfo ),GFP_KERNEL ); -if (pCifsFile ==NULL ) -return pCifsFile; - - pCifsFile->netfid = fileHandle; - pCifsFile->pid = current->tgid; - pCifsFile->uid =current_fsuid (); - pCifsFile->dentry =dget (dentry); - pCifsFile->f_flags = file->f_flags; - pCifsFile->invalidHandle = false; - pCifsFile->closePend = false; - pCifsFile->tlink =cifs_get_tlink (tlink); -mutex_init (&pCifsFile->fh_mutex); -mutex_init (&pCifsFile->lock_mutex); -INIT_LIST_HEAD (&pCifsFile->llist); -atomic_set (&pCifsFile->count,1 ); -INIT_WORK (&pCifsFile->oplock_break, cifs_oplock_break); - -write_lock (&GlobalSMBSeslock); -list_add (&pCifsFile->tlist, &(tlink_tcon (tlink)->openFileList)); - -/* if readable file instance put first in list*/ -if (file->f_mode &FMODE_READ ) -list_add (&pCifsFile->flist, &pCifsInode->openFileList); -else -list_add_tail (&pCifsFile->flist, &pCifsInode->openFileList); - -if ((oplock &0xF ) ==OPLOCK_EXCLUSIVE ) { - pCifsInode->clientCanCacheAll = true; - pCifsInode->clientCanCacheRead = true; -cFYI (1 ,"Exclusive Oplock inode %p" , inode); - }else if ((oplock &0xF ) ==OPLOCK_READ ) - pCifsInode->clientCanCacheRead = true; - -write_unlock (&GlobalSMBSeslock); - - file->private_data = pCifsFile; - -return pCifsFile; -} -int cifs_posix_open (char *full_path,struct inode **pinode,struct super_block *sb,int mode,int oflags,__u32 *poplock,__u16 *pnetfid,int xid)
fs/cifs/file.c +48 -0
54 lines not on this page · raw message
Signature · 1 line
1.7.2.3
PATCH 10/14 cifs: convert GlobalSMBSeslock from a rwlock to regular spinlock
In reply to a message not in the archiveTo prevent races we need to be able to do an atomic_dec_and_lock with it, and that won't work with a rwlock.
While we're at it, change it to have a more descriptive name without camel-case.
--- fs/cifs/cifsfs.c | 2 +- fs/cifs/cifsglob.h | 2 +- fs/cifs/cifssmb.c | 4 +- fs/cifs/file.c | 54 ++++++++++++++++++++++++++-------------------------- fs/cifs/misc.c | 8 +++--- fs/cifs/readdir.c | 6 ++-- 6 files changed, 38 insertions(+), 38 deletions(-)
fs/cifs/cifsfs.c +1 -1
@@ -939,8 +939,8 @@ init_cifs(void) GlobalTotalActiveXid =0 ; GlobalMaxActiveXid =0 ;memset (Local_System_Name,0 ,15 ); -rwlock_init (&GlobalSMBSeslock);rwlock_init (&cifs_tcp_ses_lock); +spin_lock_init (&cifs_file_list_lock);spin_lock_init (&GlobalMid_Lock);if (cifs_max_pending <2 ) {
fs/cifs/cifsglob.h +1 -1
@@ -720,7 +720,7 @@ GLOBAL_EXTERN rwlock_t cifs_tcp_ses_lock;* If cifs_tcp_ses_lock and the lock below are both needed to be held, then * the cifs_tcp_ses_lock must be grabbed first and released last. */ -GLOBAL_EXTERN rwlock_t GlobalSMBSeslock; +GLOBAL_EXTERN spinlock_t cifs_file_list_lock;/* Outstanding dir notify requests */ GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
fs/cifs/cifssmb.c +2 -2
@@ -91,13 +91,13 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)struct list_head *tmp1;/* list all files open on tree connection and mark them invalid */ -write_lock (&GlobalSMBSeslock); +spin_lock (&cifs_file_list_lock);list_for_each_safe (tmp, tmp1, &pTcon->openFileList) { open_file = list_entry(tmp, struct cifsFileInfo, tlist); open_file->invalidHandle = true; open_file->oplock_break_cancelled = true; } -write_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);/* BB Add call to invalidate_inodes(sb) for all superblocks mounted to this tcon */ }
fs/cifs/file.c +27 -27
188 lines not on this page · raw message
fs/cifs/misc.c +4 -4
@@ -560,7 +560,7 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)continue ;cifs_stats_inc (&tcon->num_oplock_brks); -read_lock (&GlobalSMBSeslock); +spin_lock (&cifs_file_list_lock);list_for_each (tmp2, &tcon->openFileList) { netfile = list_entry(tmp2, struct cifsFileInfo, tlist);
@@ -572,7 +572,7 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)* closed anyway. */ if (netfile->closePend) { -read_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);read_unlock (&cifs_tcp_ses_lock);return true; }
@@ -594,11 +594,11 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)cifs_oplock_break_get (netfile); netfile->oplock_break_cancelled = false; -read_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);read_unlock (&cifs_tcp_ses_lock);return true; } -read_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);read_unlock (&cifs_tcp_ses_lock);cFYI (1 ,"No matching file for oplock break" );return true;
fs/cifs/readdir.c +3 -3
@@ -529,14 +529,14 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon, (index_to_find < first_entry_in_buffer)) {/* close and restart search */ cFYI (1 ,"search backing up - close and restart search" ); -write_lock (&GlobalSMBSeslock); +spin_lock (&cifs_file_list_lock);if (!cifsFile->srch_inf.endOfSearch && !cifsFile->invalidHandle) { cifsFile->invalidHandle = true; -write_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);CIFSFindClose (xid, pTcon, cifsFile->netfid); }else -write_unlock (&GlobalSMBSeslock); +spin_unlock (&cifs_file_list_lock);if (cifsFile->srch_inf.ntwrk_buf_start) {cFYI (1 ,"freeing SMB ff cache buf on search rewind" );if (cifsFile->srch_inf.smallBuf)
Signature · 1 line
1.7.2.3
A message that is not in the archive (sent off-list or not yet received): 1286214781-626-11-git-send-email-jlayton-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org
Re: [PATCH 10/14] cifs: convert GlobalSMBSeslock from a rwlock to regular spinlock
Quoted 2 lines · Jeff Layton
To prevent races we need to be able to do an
atomic_dec_and_lockwith it, and that won't work with a rwlock.
It's not clear to me where a potential race window is. Could you please elaborate?
Thanks,
Signature · 1 line
Suresh Jayaraman
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH 10/14] cifs: convert GlobalSMBSeslock from a rwlock to regular spinlock
Quoted 10 lines · On Tue, 05 Oct 2010 16:00:29 +0530 Suresh Jayaraman…
Quoted 2 lines · Jeff Layton
To prevent races we need to be able to do an
atomic_dec_and_lockwith it, and that won't work with a rwlock.It's not clear to me where a potential race window is. Could you please elaborate?
Thanks,
The specific race window that I was thinking about doesn't exist today as such, but that's just because the way that filehandles are managed is so different.
When we do refcounting with atomic_t's though we need to take care that we don't act on them without taking steps to prevent races. For instance, suppose I had left the code using an rwlock_t and did this in cifsFileInfo_put:
if (atomic_dec_and_test(&open_file->count))
return;
write_lock(&GlobalSMBSeslock)
...and then tear down the cifsFileInfo. There would always be a possibility that the count increased after I checked it but before taking the lock, which could result in a use-after-free.
Now that I think about this though...it might be better to just make the count non-atomic, and simply move it under the protection of the lock. You generally need the lock anyway when you're searching for a file so there's little benefit to using an atomic here.
Signature · 1 line
Jeff Layton <[email protected]>
PATCH 11/14 cifs: move cifsFileInfo_put to file.c
In reply to a message not in the archive...and make it non-inlined in preparation for the move of most of cifs_close to it.
--- fs/cifs/cifsglob.h | 10 +--------- fs/cifs/file.c | 10 ++++++++++ 2 files changed, 11 insertions(+), 9 deletions(-)
fs/cifs/cifsglob.h +1 -9
@@ -406,15 +406,7 @@ static inline void cifsFileInfo_get(struct cifsFileInfo *cifs_file)atomic_inc (&cifs_file->count); } -/* Release a reference on the file private data */ -static inline void cifsFileInfo_put (struct cifsFileInfo *cifs_file) -{ -if (atomic_dec_and_test (&cifs_file->count)) { -cifs_put_tlink (cifs_file->tlink); -dput (cifs_file->dentry); -kfree (cifs_file); - } -} +void cifsFileInfo_put (struct cifsFileInfo *cifs_file);/* * One of these for each file inode
fs/cifs/file.c +10 -0
@@ -207,6 +207,16 @@ cifs_new_fileinfo(__u16 fileHandle, struct file *file,return pCifsFile; } +/* Release a reference on the file private data */ +void cifsFileInfo_put (struct cifsFileInfo *cifs_file) +{ +if (atomic_dec_and_test (&cifs_file->count)) { +cifs_put_tlink (cifs_file->tlink); +dput (cifs_file->dentry); +kfree (cifs_file); + } +} +int cifs_open (struct inode *inode,struct file *file) {int rc = -EACCES ;
Signature · 1 line
1.7.2.3
PATCH 12/14 cifs: move close processing from cifs_close to cifsFileInfo_put
In reply to a message not in the archiveNow that it's possible for a cifsFileInfo to outlive the filp under which it was created, move the close processing into cifsFileInfo_put.
This means that the last user of the filehandle always does the actual on the wire close call. This also allows us to get rid of the closePend flag from cifsFileInfo. If we have an active reference to the file then it's never going to have a close pending.
cifs_close is converted to simply put the filehandle.
--- fs/cifs/cifsglob.h | 1 - fs/cifs/file.c | 189 +++++++++++++++++----------------------------------- fs/cifs/misc.c | 10 --- 3 files changed, 62 insertions(+), 138 deletions(-)
fs/cifs/cifsglob.h +0 -1
@@ -391,7 +391,6 @@ struct cifsFileInfo {struct tcon_link *tlink;struct mutex lock_mutex;struct list_head llist;/* list of byte range locks we have. */ - bool closePend:1; /* file is marked to close */ bool invalidHandle:1; /* file closed via session abend */ bool oplock_break_cancelled:1;atomic_t count;/* reference count */
fs/cifs/file.c +62 -127
275 lines not on this page · raw message
fs/cifs/misc.c +0 -10
@@ -567,16 +567,6 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)if (pSMB->Fid != netfile->netfid)continue ; -/* -* don't do anything if file is about to be -* closed anyway. -*/ -if (netfile->closePend) { -spin_unlock (&cifs_file_list_lock); -read_unlock (&cifs_tcp_ses_lock); -return true; - } -cFYI (1 ,"file id match, oplock break" ); pCifsInode =CIFS_I (netfile->dentry->d_inode); pCifsInode->clientCanCacheAll = false;
Signature · 1 line
1.7.2.3
PATCH 13/14 cifs: wait for writeback to complete in cifs_flush
In reply to a message not in the archiveThe f_op->flush operation is the last chance to return a writeback related error when closing a file. Ensure that we don't miss reporting any errors by waiting for writeback to complete in cifs_flush before proceeding.
--- fs/cifs/file.c | 11 +---------- 1 files changed, 1 insertions(+), 10 deletions(-)
fs/cifs/file.c +1 -10
@@ -1628,16 +1628,7 @@ int cifs_flush(struct file *file, fl_owner_t id)struct inode *inode = file->f_path.dentry->d_inode;int rc =0 ; -/* Rather than do the steps manually: -lock the inode for writing -loop through pages looking for write behind data (dirty pages) -coalesce into contiguous 16K (or smaller) chunks to write to server -send to server (prefer in parallel) -deal with writebehind errors -unlock inode for writing -filemapfdatawrite appears easier for the time being */ - - rc =filemap_fdatawrite (inode->i_mapping); + rc =filemap_write_and_wait (inode->i_mapping);/* reset wb rc if we were able to write out dirty pages */ if (!rc) { rc =CIFS_I (inode)->write_behind_rc;
Signature · 1 line
1.7.2.3
PATCH 14/14 cifs: eliminate cifsInodeInfo->write_behind_rc
In reply to a message not in the archivewrite_behind_rc is redundant and just adds complexity to the code. What we really want to do instead is to use mapping_set_error to reset the flags on the mapping when we find a writeback error and can't report it to userspace yet.
For cifs_flush and cifs_fsync, we shouldn't reset the flags since errors returned there do get reported to userspace.
--- fs/cifs/cifsfs.c | 1 - fs/cifs/cifsglob.h | 1 - fs/cifs/file.c | 31 +++++++------------------------ fs/cifs/inode.c | 15 +++++---------- 4 files changed, 12 insertions(+), 36 deletions(-)
fs/cifs/cifsfs.c +0 -1
@@ -320,7 +320,6 @@ cifs_alloc_inode(struct super_block *sb)return NULL ; cifs_inode->cifsAttrs =0x20 ;/* default */ cifs_inode->time =0 ; - cifs_inode->write_behind_rc =0 ;/* Until the file is open and we have gotten oplock info back from the server, can not assume caching of file data or metadata */
fs/cifs/cifsglob.h +0 -1
@@ -415,7 +415,6 @@ struct cifsInodeInfo {struct list_head lockList;/* BB add in lists for dirty pages i.e. write caching info for oplock */ struct list_head openFileList; -int write_behind_rc;__u32 cifsAttrs;/* e.g. DOS archive bit, sparse, compressed, system */ unsigned long time;/* jiffies of last update/check of inode */ bool clientCanCacheRead:1; /* read oplock */
fs/cifs/file.c +7 -24
@@ -133,8 +133,7 @@ static inline int cifs_open_inode_helper(struct inode *inode,/* BB no need to lock inode until after invalidate since namei code should already have it locked? */ rc =filemap_write_and_wait (inode->i_mapping); -if (rc !=0 ) - pCifsInode->write_behind_rc = rc; +mapping_set_error (inode->i_mapping, rc); }cFYI (1 ,"invalidating remote inode since open detected it " "changed" );
@@ -545,8 +544,7 @@ reopen_success:if (pCifsInode) {if (can_flush) { rc =filemap_write_and_wait (inode->i_mapping); -if (rc !=0 ) -CIFS_I (inode)->write_behind_rc = rc; +mapping_set_error (inode->i_mapping, rc);/* temporarily disable caching while we go to server to get inode info */ pCifsInode->clientCanCacheAll = false;
@@ -1429,12 +1427,7 @@ retry:if (rc || bytes_written < bytes_to_write) {cERROR (1 ,"Write2 ret %d, wrote %d" , rc, bytes_written); -/* BB what if continued retry is -requested via mount flags? */ -if (rc == -ENOSPC ) -set_bit (AS_ENOSPC , &mapping->flags); -else -set_bit (AS_EIO , &mapping->flags); +mapping_set_error (mapping, rc); }else {cifs_stats_bytes_written (tcon, bytes_written); }
@@ -1579,10 +1572,8 @@ int cifs_fsync(struct file *file, int datasync) rc =filemap_write_and_wait (inode->i_mapping);if (rc ==0 ) { - rc =CIFS_I (inode)->write_behind_rc; -CIFS_I (inode)->write_behind_rc =0 ; tcon =tlink_tcon (smbfile->tlink); -if (!rc && tcon && smbfile && +if (rc ==0 && !(CIFS_SB (inode->i_sb)->mnt_cifs_flags &CIFS_MOUNT_NOSSYNC )) rc =CIFSSMBFlush (xid, tcon, smbfile->netfid); }
@@ -1629,11 +1620,6 @@ int cifs_flush(struct file *file, fl_owner_t id)int rc =0 ; rc =filemap_write_and_wait (inode->i_mapping); -/* reset wb rc if we were able to write out dirty pages */ -if (!rc) { - rc =CIFS_I (inode)->write_behind_rc; -CIFS_I (inode)->write_behind_rc =0 ; - }cFYI (1 ,"Flush inode %p file %p rc %d" , inode, file, rc);
@@ -2212,7 +2198,7 @@ void cifs_oplock_break(struct work_struct *work) oplock_break);struct inode *inode = cfile->dentry->d_inode;struct cifsInodeInfo *cinode =CIFS_I (inode); -int rc, waitrc =0 ; +int rc =0 ;if (inode &&S_ISREG (inode->i_mode)) {if (cinode->clientCanCacheRead)
@@ -2221,13 +2207,10 @@ void cifs_oplock_break(struct work_struct *work)break_lease (inode,O_WRONLY ); rc =filemap_fdatawrite (inode->i_mapping);if (cinode->clientCanCacheRead ==0 ) { - waitrc =filemap_fdatawait (inode->i_mapping); + rc =filemap_fdatawait (inode->i_mapping); +mapping_set_error (inode->i_mapping, rc);invalidate_remote_inode (inode); } -if (!rc) - rc = waitrc; -if (rc) - cinode->write_behind_rc = rc;cFYI (1 ,"Oplock flush inode %p rc %d" , inode, rc); }
fs/cifs/inode.c +5 -10
@@ -1688,8 +1688,7 @@ cifs_invalidate_mapping(struct inode *inode)/* write back any cached data */ if (inode->i_mapping && inode->i_mapping->nrpages !=0 ) { rc =filemap_write_and_wait (inode->i_mapping); -if (rc) - cifs_i->write_behind_rc = rc; +mapping_set_error (inode->i_mapping, rc); }invalidate_remote_inode (inode);cifs_fscache_reset_inode_cookie (inode);
@@ -1941,10 +1940,8 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)* the flush returns error? */ rc =filemap_write_and_wait (inode->i_mapping); -if (rc !=0 ) { - cifsInode->write_behind_rc = rc; - rc =0 ; - } +mapping_set_error (inode->i_mapping, rc); + rc =0 ;if (attrs->ia_valid &ATTR_SIZE ) { rc =cifs_set_file_size (inode, attrs, xid, full_path);
@@ -2085,10 +2082,8 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)* the flush returns error? */ rc =filemap_write_and_wait (inode->i_mapping); -if (rc !=0 ) { - cifsInode->write_behind_rc = rc; - rc =0 ; - } +mapping_set_error (inode->i_mapping, rc); + rc =0 ;if (attrs->ia_valid &ATTR_SIZE ) { rc =cifs_set_file_size (inode, attrs, xid, full_path);
Signature · 1 line
1.7.2.3
Quoted 9 lines · Jeff Layton
This patchset fixes a number of problems with the existing CIFS code. It eliminates the backreference to the filp from cifsFileInfo, allowing a cifsFileInfo to outlive the filp that it was generated against.
With that change, most of the closing of a filehandle on the server is moved to
cifsFileInfo_put.cifs_closeis then changed to just put the filehandle instead of trying to wait around for existing users to finish with it.
Quoted 8 lines
With this change, there is some further cleanup that can be done as well. For instance, there's no real need to continually search for new filehandles in
cifs_writepagesnow that we hold a reference to one. I'll hold back on that until I know how this set has been received.This set is an ordered set and should not be committed out of order. It should be bisectable. I've tested the resulting set and it seems to work fine.
These all look good to me. Cleans up the code rather nicely.
Shaggy
Quoted 30 lines
Jeff Layton (14):
cifs: keep dentry reference in cifsFileInfo instead of inode
reference
cifs: don't use vfsmount to pin superblock for oplock breaks
cifs: eliminatecifs_posix_open_inode_helper
cifs: eliminate oflags option fromcifs_new_fileinfo
cifs: eliminate the inode argument fromcifs_new_fileinfo
cifs: clean upcifs_reopen_file
cifs:cifs_writeargument change and cleanup
cifs: eliminate pfile pointer from cifsFileInfo
cifs: movecifs_new_fileinfotofile.c
cifs: convert GlobalSMBSeslock from a rwlock to regular spinlock
cifs: movecifsFileInfo_puttofile.c
cifs: move close processing fromcifs_closetocifsFileInfo_put
cifs: wait for writeback to complete incifs_flush
cifs: eliminatecifsInodeInfo->write_behind_rcfs/cifs/cifs_fs_sb.h | 1 + fs/cifs/cifsfs.c | 21 ++- fs/cifs/cifsfs.h | 6 +- fs/cifs/cifsglob.h | 19 +-- fs/cifs/cifsproto.h | 6 +- fs/cifs/cifssmb.c | 4 +- fs/cifs/dir.c | 60 +----- fs/cifs/file.c | 574 +++++++++++++++++++------------------------------- fs/cifs/inode.c | 15 +- fs/cifs/misc.c | 18 +-- fs/cifs/readdir.c | 6 +- 11 files changed, 260 insertions(+), 470 deletions(-)
Signature · 2 lines
Dave Kleikamp IBM Linux Technology Center
Suresh Jayaraman
Reviewed-byQuoted 9 lines · Jeff Layton
This patchset fixes a number of problems with the existing CIFS code. It eliminates the backreference to the filp from cifsFileInfo, allowing a cifsFileInfo to outlive the filp that it was generated against.
With that change, most of the closing of a filehandle on the server is moved to
cifsFileInfo_put.cifs_closeis then changed to just put the filehandle instead of trying to wait around for existing users to finish with it.
Quoted 5 lines
With this change, there is some further cleanup that can be done as well. For instance, there's no real need to continually search for new filehandles in
cifs_writepagesnow that we hold a reference to one. I'll hold back on that until I know how this set has been received.
Nice cleanups. Patches 1 to 9 looks correct to me.