iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CIFS: Replace netfid with cifs_fid struct in cifsFileInfo

Browse Source 
This is help us to extend the code for future protocols that can use
another fid mechanism (as SMB2 that has it divided into two parts:
persistent and violatile).

Also rename variables and refactor the code around the changes.

Reviewed-by: Jeff Layton <jlayton@samba.org>
Signed-off-by: Pavel Shilovsky <pshilovsky@samba.org>
Signed-off-by: Steve French <smfrench@gmail.com>
This commit is contained in:
Pavel Shilovsky 2012-09-18 16:20:26 -07:00 committed by Steve French
parent cbe6f439f5
commit 4b4de76e35
9 changed files with 85 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/cifs/cifsacl.c
View File

@ -1222,7 +1222,7 @@ struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb,
if (!open_file) if (!open_file)
return get_cifs_acl_by_path(cifs_sb, path, pacllen); return get_cifs_acl_by_path(cifs_sb, path, pacllen);
pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->netfid, pacllen); pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->fid.netfid, pacllen);
cifsFileInfo_put(open_file); cifsFileInfo_put(open_file);
return pntsd; return pntsd;
} }

6
fs/cifs/cifsglob.h
View File

@ -746,6 +746,10 @@ struct cifs_search_info {
bool smallBuf:1; /* so we know which buf_release function to call */ bool smallBuf:1; /* so we know which buf_release function to call */
}; };
struct cifs_fid {
__u16 netfid;
};
struct cifsFileInfo { struct cifsFileInfo {
struct list_head tlist; /* pointer to next fid owned by tcon */ struct list_head tlist; /* pointer to next fid owned by tcon */
struct list_head flist; /* next fid (file instance) for this inode */ struct list_head flist; /* next fid (file instance) for this inode */
@ -755,7 +759,7 @@ struct cifsFileInfo {
*/ */
unsigned int uid; /* allows finding which FileInfo structure */ unsigned int uid; /* allows finding which FileInfo structure */
__u32 pid; /* process id who opened file */ __u32 pid; /* process id who opened file */
__u16 netfid; /* file id from remote */ struct cifs_fid fid; /* file id from remote */
/* BB add lock scope info here if needed */ ; /* BB add lock scope info here if needed */ ;
/* lock scope id (0 if none) */ /* lock scope id (0 if none) */
struct dentry *dentry; struct dentry *dentry;

4
fs/cifs/cifssmb.c
View File

@ -1632,7 +1632,7 @@ cifs_async_readv(struct cifs_readdata *rdata)
smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16)); smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
smb->AndXCommand = 0xFF; /* none */ smb->AndXCommand = 0xFF; /* none */
smb->Fid = rdata->cfile->netfid; smb->Fid = rdata->cfile->fid.netfid;
smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF); smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
if (wct == 12) if (wct == 12)
smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32); smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
@ -2084,7 +2084,7 @@ cifs_async_writev(struct cifs_writedata *wdata)
smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16)); smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
smb->AndXCommand = 0xFF; /* none */ smb->AndXCommand = 0xFF; /* none */
smb->Fid = wdata->cfile->netfid; smb->Fid = wdata->cfile->fid.netfid;
smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF); smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
if (wct == 14) if (wct == 14)
smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32); smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);

112
fs/cifs/file.c
View File

@ -247,39 +247,39 @@ cifs_new_fileinfo(__u16 fileHandle, struct file *file,
{ {
struct dentry *dentry = file->f_path.dentry; struct dentry *dentry = file->f_path.dentry;
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
struct cifsInodeInfo *pCifsInode = CIFS_I(inode); struct cifsInodeInfo *cinode = CIFS_I(inode);
struct cifsFileInfo *pCifsFile; struct cifsFileInfo *cfile;
pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL); cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
if (pCifsFile == NULL) if (cfile == NULL)
return pCifsFile; return cfile;
pCifsFile->count = 1; cfile->count = 1;
pCifsFile->netfid = fileHandle; cfile->fid.netfid = fileHandle;
pCifsFile->pid = current->tgid; cfile->pid = current->tgid;
pCifsFile->uid = current_fsuid(); cfile->uid = current_fsuid();
pCifsFile->dentry = dget(dentry); cfile->dentry = dget(dentry);
pCifsFile->f_flags = file->f_flags; cfile->f_flags = file->f_flags;
pCifsFile->invalidHandle = false; cfile->invalidHandle = false;
pCifsFile->tlink = cifs_get_tlink(tlink); cfile->tlink = cifs_get_tlink(tlink);
mutex_init(&pCifsFile->fh_mutex); mutex_init(&cfile->fh_mutex);
INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break); INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
INIT_LIST_HEAD(&pCifsFile->llist); INIT_LIST_HEAD(&cfile->llist);
spin_lock(&cifs_file_list_lock); spin_lock(&cifs_file_list_lock);
list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList)); list_add(&cfile->tlist, &(tlink_tcon(tlink)->openFileList));
/* if readable file instance put first in list*/ /* if readable file instance put first in list*/
if (file->f_mode & FMODE_READ) if (file->f_mode & FMODE_READ)
list_add(&pCifsFile->flist, &pCifsInode->openFileList); list_add(&cfile->flist, &cinode->openFileList);
else else
list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList); list_add_tail(&cfile->flist, &cinode->openFileList);
spin_unlock(&cifs_file_list_lock); spin_unlock(&cifs_file_list_lock);
cifs_set_oplock_level(pCifsInode, oplock); cifs_set_oplock_level(cinode, oplock);
pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll; cinode->can_cache_brlcks = cinode->clientCanCacheAll;
file->private_data = pCifsFile; file->private_data = cfile;
return pCifsFile; return cfile;
} }
static void cifs_del_lock_waiters(struct cifsLockInfo *lock); static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
@ -336,7 +336,7 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
unsigned int xid; unsigned int xid;
int rc; int rc;
xid = get_xid(); xid = get_xid();
rc = CIFSSMBClose(xid, tcon, cifs_file->netfid); rc = CIFSSMBClose(xid, tcon, cifs_file->fid.netfid);
free_xid(xid); free_xid(xid);
} }
@ -561,7 +561,7 @@ static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
} }
reopen_success: reopen_success:
pCifsFile->netfid = netfid; pCifsFile->fid.netfid = netfid;
pCifsFile->invalidHandle = false; pCifsFile->invalidHandle = false;
mutex_unlock(&pCifsFile->fh_mutex); mutex_unlock(&pCifsFile->fh_mutex);
pCifsInode = CIFS_I(inode); pCifsInode = CIFS_I(inode);
@ -609,39 +609,37 @@ int cifs_closedir(struct inode *inode, struct file *file)
{ {
int rc = 0; int rc = 0;
unsigned int xid; unsigned int xid;
struct cifsFileInfo *pCFileStruct = file->private_data; struct cifsFileInfo *cfile = file->private_data;
char *ptmp; char *tmp;
cFYI(1, "Closedir inode = 0x%p", inode); cFYI(1, "Closedir inode = 0x%p", inode);
xid = get_xid(); xid = get_xid();
if (pCFileStruct) { if (cfile) {
struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink); struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
cFYI(1, "Freeing private data in close dir"); cFYI(1, "Freeing private data in close dir");
spin_lock(&cifs_file_list_lock); spin_lock(&cifs_file_list_lock);
if (!pCFileStruct->srch_inf.endOfSearch && if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
!pCFileStruct->invalidHandle) { cfile->invalidHandle = true;
pCFileStruct->invalidHandle = true;
spin_unlock(&cifs_file_list_lock); spin_unlock(&cifs_file_list_lock);
rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid); rc = CIFSFindClose(xid, tcon, cfile->fid.netfid);
cFYI(1, "Closing uncompleted readdir with rc %d", cFYI(1, "Closing uncompleted readdir with rc %d", rc);
rc);
/* not much we can do if it fails anyway, ignore rc */ /* not much we can do if it fails anyway, ignore rc */
rc = 0; rc = 0;
} else } else
spin_unlock(&cifs_file_list_lock); spin_unlock(&cifs_file_list_lock);
ptmp = pCFileStruct->srch_inf.ntwrk_buf_start; tmp = cfile->srch_inf.ntwrk_buf_start;
if (ptmp) { if (tmp) {
cFYI(1, "closedir free smb buf in srch struct"); cFYI(1, "closedir free smb buf in srch struct");
pCFileStruct->srch_inf.ntwrk_buf_start = NULL; cfile->srch_inf.ntwrk_buf_start = NULL;
if (pCFileStruct->srch_inf.smallBuf) if (cfile->srch_inf.smallBuf)
cifs_small_buf_release(ptmp); cifs_small_buf_release(tmp);
else else
cifs_buf_release(ptmp); cifs_buf_release(tmp);
} }
cifs_put_tlink(pCFileStruct->tlink); cifs_put_tlink(cfile->tlink);
kfree(file->private_data); kfree(file->private_data);
file->private_data = NULL; file->private_data = NULL;
} }
@ -932,7 +930,8 @@ cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
cur->OffsetLow = cpu_to_le32((u32)li->offset); cur->OffsetLow = cpu_to_le32((u32)li->offset);
cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32)); cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
if (++num == max_num) { if (++num == max_num) {
stored_rc = cifs_lockv(xid, tcon, cfile->netfid, stored_rc = cifs_lockv(xid, tcon,
cfile->fid.netfid,
(__u8)li->type, 0, num, (__u8)li->type, 0, num,
buf); buf);
if (stored_rc) if (stored_rc)
@ -944,7 +943,7 @@ cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
} }
if (num) { if (num) {
stored_rc = cifs_lockv(xid, tcon, cfile->netfid, stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
(__u8)types[i], 0, num, buf); (__u8)types[i], 0, num, buf);
if (stored_rc) if (stored_rc)
rc = stored_rc; rc = stored_rc;
@ -1038,7 +1037,7 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile)
type = CIFS_WRLCK; type = CIFS_WRLCK;
lck = list_entry(el, struct lock_to_push, llist); lck = list_entry(el, struct lock_to_push, llist);
lck->pid = flock->fl_pid; lck->pid = flock->fl_pid;
lck->netfid = cfile->netfid; lck->netfid = cfile->fid.netfid;
lck->length = length; lck->length = length;
lck->type = type; lck->type = type;
lck->offset = flock->fl_start; lck->offset = flock->fl_start;
@ -1137,7 +1136,7 @@ static int
cifs_mandatory_lock(unsigned int xid, struct cifsFileInfo *cfile, __u64 offset, cifs_mandatory_lock(unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
__u64 length, __u32 type, int lock, int unlock, bool wait) __u64 length, __u32 type, int lock, int unlock, bool wait)
{ {
return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->netfid, return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid,
current->tgid, length, offset, unlock, lock, current->tgid, length, offset, unlock, lock,
(__u8)type, wait, 0); (__u8)type, wait, 0);
} }
@ -1151,7 +1150,7 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
struct TCP_Server_Info *server = tcon->ses->server; struct TCP_Server_Info *server = tcon->ses->server;
__u16 netfid = cfile->netfid; __u16 netfid = cfile->fid.netfid;
if (posix_lck) { if (posix_lck) {
int posix_lock_type; int posix_lock_type;
@ -1295,7 +1294,8 @@ cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
*/ */
list_move(&li->llist, &tmp_llist); list_move(&li->llist, &tmp_llist);
if (++num == max_num) { if (++num == max_num) {
stored_rc = cifs_lockv(xid, tcon, cfile->netfid, stored_rc = cifs_lockv(xid, tcon,
cfile->fid.netfid,
li->type, num, 0, buf); li->type, num, 0, buf);
if (stored_rc) { if (stored_rc) {
/* /*
@ -1318,7 +1318,7 @@ cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
cur++; cur++;
} }
if (num) { if (num) {
stored_rc = cifs_lockv(xid, tcon, cfile->netfid, stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
types[i], num, 0, buf); types[i], num, 0, buf);
if (stored_rc) { if (stored_rc) {
cifs_move_llist(&tmp_llist, &cfile->llist); cifs_move_llist(&tmp_llist, &cfile->llist);
@ -1343,7 +1343,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
struct TCP_Server_Info *server = tcon->ses->server; struct TCP_Server_Info *server = tcon->ses->server;
__u16 netfid = cfile->netfid; __u16 netfid = cfile->fid.netfid;
if (posix_lck) { if (posix_lck) {
int posix_lock_type; int posix_lock_type;
@ -1423,7 +1423,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
tcon->ses->server); tcon->ses->server);
cifs_sb = CIFS_SB(file->f_path.dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
netfid = cfile->netfid; netfid = cfile->fid.netfid;
cinode = CIFS_I(file->f_path.dentry->d_inode); cinode = CIFS_I(file->f_path.dentry->d_inode);
if (cap_unix(tcon->ses) && if (cap_unix(tcon->ses) &&
@ -1514,7 +1514,7 @@ static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
/* iov[0] is reserved for smb header */ /* iov[0] is reserved for smb header */
iov[1].iov_base = (char *)write_data + total_written; iov[1].iov_base = (char *)write_data + total_written;
iov[1].iov_len = len; iov[1].iov_len = len;
io_parms.netfid = open_file->netfid; io_parms.netfid = open_file->fid.netfid;
io_parms.pid = pid; io_parms.pid = pid;
io_parms.tcon = pTcon; io_parms.tcon = pTcon;
io_parms.offset = *poffset; io_parms.offset = *poffset;
@ -2078,7 +2078,7 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
tcon = tlink_tcon(smbfile->tlink); tcon = tlink_tcon(smbfile->tlink);
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
rc = CIFSSMBFlush(xid, tcon, smbfile->netfid); rc = CIFSSMBFlush(xid, tcon, smbfile->fid.netfid);
free_xid(xid); free_xid(xid);
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
@ -2106,7 +2106,7 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
tcon = tlink_tcon(smbfile->tlink); tcon = tlink_tcon(smbfile->tlink);
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
rc = CIFSSMBFlush(xid, tcon, smbfile->netfid); rc = CIFSSMBFlush(xid, tcon, smbfile->fid.netfid);
free_xid(xid); free_xid(xid);
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
@ -2802,7 +2802,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
if (rc != 0) if (rc != 0)
break; break;
} }
io_parms.netfid = open_file->netfid; io_parms.netfid = open_file->fid.netfid;
io_parms.pid = pid; io_parms.pid = pid;
io_parms.tcon = tcon; io_parms.tcon = tcon;
io_parms.offset = *poffset; io_parms.offset = *poffset;
@ -3374,7 +3374,7 @@ void cifs_oplock_break(struct work_struct *work)
* disconnected since oplock already released by the server * disconnected since oplock already released by the server
*/ */
if (!cfile->oplock_break_cancelled) { if (!cfile->oplock_break_cancelled) {
rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->fid.netfid,
current->tgid, 0, 0, 0, 0, current->tgid, 0, 0, 0, 0,
LOCKING_ANDX_OPLOCK_RELEASE, false, LOCKING_ANDX_OPLOCK_RELEASE, false,
cinode->clientCanCacheRead ? 1 : 0); cinode->clientCanCacheRead ? 1 : 0);

10
fs/cifs/inode.c
View File

@ -294,7 +294,7 @@ int cifs_get_file_info_unix(struct file *filp)
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
xid = get_xid(); xid = get_xid();
rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data); rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
if (!rc) { if (!rc) {
cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb); cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
} else if (rc == -EREMOTE) { } else if (rc == -EREMOTE) {
@ -562,7 +562,7 @@ int cifs_get_file_info(struct file *filp)
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
xid = get_xid(); xid = get_xid();
rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data); rc = CIFSSMBQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
switch (rc) { switch (rc) {
case 0: case 0:
cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false); cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
@ -930,7 +930,7 @@ cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
*/ */
open_file = find_writable_file(cifsInode, true); open_file = find_writable_file(cifsInode, true);
if (open_file) { if (open_file) {
netfid = open_file->netfid; netfid = open_file->fid.netfid;
netpid = open_file->pid; netpid = open_file->pid;
pTcon = tlink_tcon(open_file->tlink); pTcon = tlink_tcon(open_file->tlink);
goto set_via_filehandle; goto set_via_filehandle;
@ -1887,7 +1887,7 @@ cifs_set_file_size(struct inode *inode, struct iattr *attrs,
*/ */
open_file = find_writable_file(cifsInode, true); open_file = find_writable_file(cifsInode, true);
if (open_file) { if (open_file) {
__u16 nfid = open_file->netfid; __u16 nfid = open_file->fid.netfid;
__u32 npid = open_file->pid; __u32 npid = open_file->pid;
pTcon = tlink_tcon(open_file->tlink); pTcon = tlink_tcon(open_file->tlink);
rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid, rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
@ -2061,7 +2061,7 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
args->device = 0; args->device = 0;
open_file = find_writable_file(cifsInode, true); open_file = find_writable_file(cifsInode, true);
if (open_file) { if (open_file) {
u16 nfid = open_file->netfid; u16 nfid = open_file->fid.netfid;
u32 npid = open_file->pid; u32 npid = open_file->pid;
pTcon = tlink_tcon(open_file->tlink); pTcon = tlink_tcon(open_file->tlink);
rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid); rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);

13
fs/cifs/ioctl.c
View File

@ -75,8 +75,9 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
tcon = tlink_tcon(pSMBFile->tlink); tcon = tlink_tcon(pSMBFile->tlink);
caps = le64_to_cpu(tcon->fsUnixInfo.Capability); caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
if (CIFS_UNIX_EXTATTR_CAP & caps) { if (CIFS_UNIX_EXTATTR_CAP & caps) {
rc = CIFSGetExtAttr(xid, tcon, pSMBFile->netfid, rc = CIFSGetExtAttr(xid, tcon,
&ExtAttrBits, &ExtAttrMask); pSMBFile->fid.netfid,
&ExtAttrBits, &ExtAttrMask);
if (rc == 0) if (rc == 0)
rc = put_user(ExtAttrBits & rc = put_user(ExtAttrBits &
FS_FL_USER_VISIBLE, FS_FL_USER_VISIBLE,
@ -94,8 +95,12 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
rc = -EFAULT; rc = -EFAULT;
break; break;
} }
/* rc= CIFSGetExtAttr(xid,tcon,pSMBFile->netfid, /*
extAttrBits, &ExtAttrMask);*/ * rc = CIFSGetExtAttr(xid, tcon,
* pSMBFile->fid.netfid,
* extAttrBits,
* &ExtAttrMask);
*/
} }
cFYI(1, "set flags not implemented yet"); cFYI(1, "set flags not implemented yet");
break; break;

2
fs/cifs/misc.c
View File

@ -466,7 +466,7 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
list_for_each(tmp2, &tcon->openFileList) { list_for_each(tmp2, &tcon->openFileList) {
netfile = list_entry(tmp2, struct cifsFileInfo, netfile = list_entry(tmp2, struct cifsFileInfo,
tlist); tlist);
if (pSMB->Fid != netfile->netfid) if (pSMB->Fid != netfile->fid.netfid)
continue; continue;
cFYI(1, "file id match, oplock break"); cFYI(1, "file id match, oplock break");

10
fs/cifs/readdir.c
View File

@ -279,7 +279,7 @@ ffirst_retry:
search_flags |= CIFS_SEARCH_BACKUP_SEARCH; search_flags |= CIFS_SEARCH_BACKUP_SEARCH;
rc = CIFSFindFirst(xid, tcon, full_path, cifs_sb->local_nls, rc = CIFSFindFirst(xid, tcon, full_path, cifs_sb->local_nls,
&cifsFile->netfid, search_flags, &cifsFile->srch_inf, &cifsFile->fid.netfid, search_flags, &cifsFile->srch_inf,
cifs_sb->mnt_cifs_flags & cifs_sb->mnt_cifs_flags &
CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb)); CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
if (rc == 0) if (rc == 0)
@ -545,7 +545,7 @@ static int find_cifs_entry(const unsigned int xid, struct cifs_tcon *pTcon,
!cifsFile->invalidHandle) { !cifsFile->invalidHandle) {
cifsFile->invalidHandle = true; cifsFile->invalidHandle = true;
spin_unlock(&cifs_file_list_lock); spin_unlock(&cifs_file_list_lock);
CIFSFindClose(xid, pTcon, cifsFile->netfid); CIFSFindClose(xid, pTcon, cifsFile->fid.netfid);
} else } else
spin_unlock(&cifs_file_list_lock); spin_unlock(&cifs_file_list_lock);
if (cifsFile->srch_inf.ntwrk_buf_start) { if (cifsFile->srch_inf.ntwrk_buf_start) {
@ -577,8 +577,8 @@ static int find_cifs_entry(const unsigned int xid, struct cifs_tcon *pTcon,
while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) && while ((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
(rc == 0) && !cifsFile->srch_inf.endOfSearch) { (rc == 0) && !cifsFile->srch_inf.endOfSearch) {
cFYI(1, "calling findnext2"); cFYI(1, "calling findnext2");
rc = CIFSFindNext(xid, pTcon, cifsFile->netfid, search_flags, rc = CIFSFindNext(xid, pTcon, cifsFile->fid.netfid,
&cifsFile->srch_inf); search_flags, &cifsFile->srch_inf);
/* FindFirst/Next set last_entry to NULL on malformed reply */ /* FindFirst/Next set last_entry to NULL on malformed reply */
if (cifsFile->srch_inf.last_entry) if (cifsFile->srch_inf.last_entry)
cifs_save_resume_key(cifsFile->srch_inf.last_entry, cifs_save_resume_key(cifsFile->srch_inf.last_entry,
@ -781,7 +781,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
} }
} /* else { } /* else {
cifsFile->invalidHandle = true; cifsFile->invalidHandle = true;
CIFSFindClose(xid, pTcon, cifsFile->netfid); CIFSFindClose(xid, pTcon, cifsFile->fid.netfid);
} */ } */
pTcon = tlink_tcon(cifsFile->tlink); pTcon = tlink_tcon(cifsFile->tlink);

2
fs/cifs/smb1ops.c
View File

@ -63,7 +63,7 @@ send_nt_cancel(struct TCP_Server_Info *server, void *buf,
static bool static bool
cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2) cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
{ {
return ob1->netfid == ob2->netfid; return ob1->fid.netfid == ob2->fid.netfid;
} }
static unsigned int static unsigned int