Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[PATCH] cifs: change uses of f_{dentry, vfsmnt} to use f_path

Browse source 
Change all the uses of f_{dentry,vfsmnt} to f_path.{dentry,mnt} in the cifs
filesystem.

Signed-off-by: Josef "Jeff" Sipek <jsipek@cs.sunysb.edu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Josef "Jeff" Sipek 2006-12-08 02:36:48 -08:00 committed by Linus Torvalds
parent 867fa491a2
commit e6a002964c
4 changed files with 77 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
fs/cifs/cifsfs.c
View file

@ -498,7 +498,7 @@ cifs_get_sb(struct file_system_type *fs_type,
static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov, static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos) unsigned long nr_segs, loff_t pos)
{ {
struct inode *inode = iocb->ki_filp->f_dentry->d_inode; struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
ssize_t written; ssize_t written;
written = generic_file_aio_write(iocb, iov, nr_segs, pos); written = generic_file_aio_write(iocb, iov, nr_segs, pos);
@ -511,7 +511,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
{ {
/* origin == SEEK_END => we must revalidate the cached file length */ /* origin == SEEK_END => we must revalidate the cached file length */
if (origin == SEEK_END) { if (origin == SEEK_END) {
int retval = cifs_revalidate(file->f_dentry); int retval = cifs_revalidate(file->f_path.dentry);
if (retval < 0) if (retval < 0)
return (loff_t)retval; return (loff_t)retval;
} }

4
fs/cifs/fcntl.c
View file

@ -83,10 +83,10 @@ int cifs_dir_notify(struct file * file, unsigned long arg)
return 0; return 0;
xid = GetXid(); xid = GetXid();
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
full_path = build_path_from_dentry(file->f_dentry); full_path = build_path_from_dentry(file->f_path.dentry);
if(full_path == NULL) { if(full_path == NULL) {
rc = -ENOMEM; rc = -ENOMEM;

114
fs/cifs/file.c
View file

@ -122,34 +122,34 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
/* if not oplocked, invalidate inode pages if mtime or file /* if not oplocked, invalidate inode pages if mtime or file
size changed */ size changed */
temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime)); temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) && if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
(file->f_dentry->d_inode->i_size == (file->f_path.dentry->d_inode->i_size ==
(loff_t)le64_to_cpu(buf->EndOfFile))) { (loff_t)le64_to_cpu(buf->EndOfFile))) {
cFYI(1, ("inode unchanged on server")); cFYI(1, ("inode unchanged on server"));
} else { } else {
if (file->f_dentry->d_inode->i_mapping) { if (file->f_path.dentry->d_inode->i_mapping) {
/* BB no need to lock inode until after invalidate /* BB no need to lock inode until after invalidate
since namei code should already have it locked? */ since namei code should already have it locked? */
filemap_write_and_wait(file->f_dentry->d_inode->i_mapping); filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
} }
cFYI(1, ("invalidating remote inode since open detected it " cFYI(1, ("invalidating remote inode since open detected it "
"changed")); "changed"));
invalidate_remote_inode(file->f_dentry->d_inode); invalidate_remote_inode(file->f_path.dentry->d_inode);
} }
client_can_cache: client_can_cache:
if (pTcon->ses->capabilities & CAP_UNIX) if (pTcon->ses->capabilities & CAP_UNIX)
rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode, rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
full_path, inode->i_sb, xid); full_path, inode->i_sb, xid);
else else
rc = cifs_get_inode_info(&file->f_dentry->d_inode, rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
full_path, buf, inode->i_sb, xid); full_path, buf, inode->i_sb, xid);
if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) { if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
pCifsInode->clientCanCacheAll = TRUE; pCifsInode->clientCanCacheAll = TRUE;
pCifsInode->clientCanCacheRead = TRUE; pCifsInode->clientCanCacheRead = TRUE;
cFYI(1, ("Exclusive Oplock granted on inode %p", cFYI(1, ("Exclusive Oplock granted on inode %p",
file->f_dentry->d_inode)); file->f_path.dentry->d_inode));
} else if ((*oplock & 0xF) == OPLOCK_READ) } else if ((*oplock & 0xF) == OPLOCK_READ)
pCifsInode->clientCanCacheRead = TRUE; pCifsInode->clientCanCacheRead = TRUE;
@ -178,7 +178,7 @@ int cifs_open(struct inode *inode, struct file *file)
if (file->f_flags & O_CREAT) { if (file->f_flags & O_CREAT) {
/* search inode for this file and fill in file->private_data */ /* search inode for this file and fill in file->private_data */
pCifsInode = CIFS_I(file->f_dentry->d_inode); pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
read_lock(&GlobalSMBSeslock); read_lock(&GlobalSMBSeslock);
list_for_each(tmp, &pCifsInode->openFileList) { list_for_each(tmp, &pCifsInode->openFileList) {
pCifsFile = list_entry(tmp, struct cifsFileInfo, pCifsFile = list_entry(tmp, struct cifsFileInfo,
@ -206,7 +206,7 @@ int cifs_open(struct inode *inode, struct file *file)
} }
} }
full_path = build_path_from_dentry(file->f_dentry); full_path = build_path_from_dentry(file->f_path.dentry);
if (full_path == NULL) { if (full_path == NULL) {
FreeXid(xid); FreeXid(xid);
return -ENOMEM; return -ENOMEM;
@ -291,7 +291,7 @@ int cifs_open(struct inode *inode, struct file *file)
write_lock(&GlobalSMBSeslock); write_lock(&GlobalSMBSeslock);
list_add(&pCifsFile->tlist, &pTcon->openFileList); list_add(&pCifsFile->tlist, &pTcon->openFileList);
pCifsInode = CIFS_I(file->f_dentry->d_inode); pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
if (pCifsInode) { if (pCifsInode) {
rc = cifs_open_inode_helper(inode, file, pCifsInode, rc = cifs_open_inode_helper(inode, file, pCifsInode,
pCifsFile, pTcon, pCifsFile, pTcon,
@ -366,7 +366,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
return 0; return 0;
} }
if (file->f_dentry == NULL) { if (file->f_path.dentry == NULL) {
up(&pCifsFile->fh_sem); up(&pCifsFile->fh_sem);
cFYI(1, ("failed file reopen, no valid name if dentry freed")); cFYI(1, ("failed file reopen, no valid name if dentry freed"));
FreeXid(xid); FreeXid(xid);
@ -378,7 +378,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
those that already have the rename sem can end up causing writepage those that already have the rename sem can end up causing writepage
to get called and if the server was down that means we end up here, to get called and if the server was down that means we end up here,
and we can never tell if the caller already has the rename_sem */ and we can never tell if the caller already has the rename_sem */
full_path = build_path_from_dentry(file->f_dentry); full_path = build_path_from_dentry(file->f_path.dentry);
if (full_path == NULL) { if (full_path == NULL) {
up(&pCifsFile->fh_sem); up(&pCifsFile->fh_sem);
FreeXid(xid); FreeXid(xid);
@ -444,7 +444,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
pCifsInode->clientCanCacheAll = TRUE; pCifsInode->clientCanCacheAll = TRUE;
pCifsInode->clientCanCacheRead = TRUE; pCifsInode->clientCanCacheRead = TRUE;
cFYI(1, ("Exclusive Oplock granted on inode %p", cFYI(1, ("Exclusive Oplock granted on inode %p",
file->f_dentry->d_inode)); file->f_path.dentry->d_inode));
} else if ((oplock & 0xF) == OPLOCK_READ) { } else if ((oplock & 0xF) == OPLOCK_READ) {
pCifsInode->clientCanCacheRead = TRUE; pCifsInode->clientCanCacheRead = TRUE;
pCifsInode->clientCanCacheAll = FALSE; pCifsInode->clientCanCacheAll = FALSE;
@ -551,7 +551,7 @@ int cifs_closedir(struct inode *inode, struct file *file)
if (pCFileStruct) { if (pCFileStruct) {
struct cifsTconInfo *pTcon; struct cifsTconInfo *pTcon;
struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb); struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
@ -664,7 +664,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
} else } else
cFYI(1, ("Unknown type of lock")); cFYI(1, ("Unknown type of lock"));
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
if (file->private_data == NULL) { if (file->private_data == NULL) {
@ -791,10 +791,10 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
int xid, long_op; int xid, long_op;
struct cifsFileInfo *open_file; struct cifsFileInfo *open_file;
if (file->f_dentry == NULL) if (file->f_path.dentry == NULL)
return -EBADF; return -EBADF;
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
if (cifs_sb == NULL) if (cifs_sb == NULL)
return -EBADF; return -EBADF;
@ -802,7 +802,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
/* cFYI(1, /* cFYI(1,
(" write %d bytes to offset %lld of %s", write_size, (" write %d bytes to offset %lld of %s", write_size,
*poffset, file->f_dentry->d_name.name)); */ *poffset, file->f_path.dentry->d_name.name)); */
if (file->private_data == NULL) if (file->private_data == NULL)
return -EBADF; return -EBADF;
@ -810,12 +810,12 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
open_file = (struct cifsFileInfo *) file->private_data; open_file = (struct cifsFileInfo *) file->private_data;
xid = GetXid(); xid = GetXid();
if (file->f_dentry->d_inode == NULL) { if (file->f_path.dentry->d_inode == NULL) {
FreeXid(xid); FreeXid(xid);
return -EBADF; return -EBADF;
} }
if (*poffset > file->f_dentry->d_inode->i_size) if (*poffset > file->f_path.dentry->d_inode->i_size)
long_op = 2; /* writes past end of file can take a long time */ long_op = 2; /* writes past end of file can take a long time */
else else
long_op = 1; long_op = 1;
@ -840,8 +840,8 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
return -EBADF; return -EBADF;
} }
if (open_file->invalidHandle) { if (open_file->invalidHandle) {
if ((file->f_dentry == NULL) || if ((file->f_path.dentry == NULL) ||
(file->f_dentry->d_inode == NULL)) { (file->f_path.dentry->d_inode == NULL)) {
FreeXid(xid); FreeXid(xid);
return total_written; return total_written;
} }
@ -849,7 +849,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
filemap_fdatawait from here so tell filemap_fdatawait from here so tell
reopen_file not to flush data to server reopen_file not to flush data to server
now */ now */
rc = cifs_reopen_file(file->f_dentry->d_inode, rc = cifs_reopen_file(file->f_path.dentry->d_inode,
file, FALSE); file, FALSE);
if (rc != 0) if (rc != 0)
break; break;
@ -878,17 +878,17 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
cifs_stats_bytes_written(pTcon, total_written); cifs_stats_bytes_written(pTcon, total_written);
/* since the write may have blocked check these pointers again */ /* since the write may have blocked check these pointers again */
if (file->f_dentry) { if (file->f_path.dentry) {
if (file->f_dentry->d_inode) { if (file->f_path.dentry->d_inode) {
struct inode *inode = file->f_dentry->d_inode; struct inode *inode = file->f_path.dentry->d_inode;
inode->i_ctime = inode->i_mtime = inode->i_ctime = inode->i_mtime =
current_fs_time(inode->i_sb); current_fs_time(inode->i_sb);
if (total_written > 0) { if (total_written > 0) {
if (*poffset > file->f_dentry->d_inode->i_size) if (*poffset > file->f_path.dentry->d_inode->i_size)
i_size_write(file->f_dentry->d_inode, i_size_write(file->f_path.dentry->d_inode,
*poffset); *poffset);
} }
mark_inode_dirty_sync(file->f_dentry->d_inode); mark_inode_dirty_sync(file->f_path.dentry->d_inode);
} }
} }
FreeXid(xid); FreeXid(xid);
@ -906,17 +906,17 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
int xid, long_op; int xid, long_op;
struct cifsFileInfo *open_file; struct cifsFileInfo *open_file;
if (file->f_dentry == NULL) if (file->f_path.dentry == NULL)
return -EBADF; return -EBADF;
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
if (cifs_sb == NULL) if (cifs_sb == NULL)
return -EBADF; return -EBADF;
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
cFYI(1,("write %zd bytes to offset %lld of %s", write_size, cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
*poffset, file->f_dentry->d_name.name)); *poffset, file->f_path.dentry->d_name.name));
if (file->private_data == NULL) if (file->private_data == NULL)
return -EBADF; return -EBADF;
@ -924,12 +924,12 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
open_file = (struct cifsFileInfo *)file->private_data; open_file = (struct cifsFileInfo *)file->private_data;
xid = GetXid(); xid = GetXid();
if (file->f_dentry->d_inode == NULL) { if (file->f_path.dentry->d_inode == NULL) {
FreeXid(xid); FreeXid(xid);
return -EBADF; return -EBADF;
} }
if (*poffset > file->f_dentry->d_inode->i_size) if (*poffset > file->f_path.dentry->d_inode->i_size)
long_op = 2; /* writes past end of file can take a long time */ long_op = 2; /* writes past end of file can take a long time */
else else
long_op = 1; long_op = 1;
@ -955,8 +955,8 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
return -EBADF; return -EBADF;
} }
if (open_file->invalidHandle) { if (open_file->invalidHandle) {
if ((file->f_dentry == NULL) || if ((file->f_path.dentry == NULL) ||
(file->f_dentry->d_inode == NULL)) { (file->f_path.dentry->d_inode == NULL)) {
FreeXid(xid); FreeXid(xid);
return total_written; return total_written;
} }
@ -964,7 +964,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
filemap_fdatawait from here so tell filemap_fdatawait from here so tell
reopen_file not to flush data to reopen_file not to flush data to
server now */ server now */
rc = cifs_reopen_file(file->f_dentry->d_inode, rc = cifs_reopen_file(file->f_path.dentry->d_inode,
file, FALSE); file, FALSE);
if (rc != 0) if (rc != 0)
break; break;
@ -1011,16 +1011,16 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
cifs_stats_bytes_written(pTcon, total_written); cifs_stats_bytes_written(pTcon, total_written);
/* since the write may have blocked check these pointers again */ /* since the write may have blocked check these pointers again */
if (file->f_dentry) { if (file->f_path.dentry) {
if (file->f_dentry->d_inode) { if (file->f_path.dentry->d_inode) {
file->f_dentry->d_inode->i_ctime = file->f_path.dentry->d_inode->i_ctime =
file->f_dentry->d_inode->i_mtime = CURRENT_TIME; file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;
if (total_written > 0) { if (total_written > 0) {
if (*poffset > file->f_dentry->d_inode->i_size) if (*poffset > file->f_path.dentry->d_inode->i_size)
i_size_write(file->f_dentry->d_inode, i_size_write(file->f_path.dentry->d_inode,
*poffset); *poffset);
} }
mark_inode_dirty_sync(file->f_dentry->d_inode); mark_inode_dirty_sync(file->f_path.dentry->d_inode);
} }
} }
FreeXid(xid); FreeXid(xid);
@ -1384,7 +1384,7 @@ static int cifs_commit_write(struct file *file, struct page *page,
if ((open_file->invalidHandle) && if ((open_file->invalidHandle) &&
(!open_file->closePend)) { (!open_file->closePend)) {
rc = cifs_reopen_file( rc = cifs_reopen_file(
file->f_dentry->d_inode, file); file->f_path.dentry->d_inode, file);
if (rc != 0) if (rc != 0)
break; break;
} }
@ -1434,7 +1434,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
{ {
int xid; int xid;
int rc = 0; int rc = 0;
struct inode *inode = file->f_dentry->d_inode; struct inode *inode = file->f_path.dentry->d_inode;
xid = GetXid(); xid = GetXid();
@ -1482,7 +1482,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
*/ */
int cifs_flush(struct file *file, fl_owner_t id) int cifs_flush(struct file *file, fl_owner_t id)
{ {
struct inode * inode = file->f_dentry->d_inode; struct inode * inode = file->f_path.dentry->d_inode;
int rc = 0; int rc = 0;
/* Rather than do the steps manually: /* Rather than do the steps manually:
@ -1519,7 +1519,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
struct smb_com_read_rsp *pSMBr; struct smb_com_read_rsp *pSMBr;
xid = GetXid(); xid = GetXid();
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
if (file->private_data == NULL) { if (file->private_data == NULL) {
@ -1542,7 +1542,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
int buf_type = CIFS_NO_BUFFER; int buf_type = CIFS_NO_BUFFER;
if ((open_file->invalidHandle) && if ((open_file->invalidHandle) &&
(!open_file->closePend)) { (!open_file->closePend)) {
rc = cifs_reopen_file(file->f_dentry->d_inode, rc = cifs_reopen_file(file->f_path.dentry->d_inode,
file, TRUE); file, TRUE);
if (rc != 0) if (rc != 0)
break; break;
@ -1601,7 +1601,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
int buf_type = CIFS_NO_BUFFER; int buf_type = CIFS_NO_BUFFER;
xid = GetXid(); xid = GetXid();
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
if (file->private_data == NULL) { if (file->private_data == NULL) {
@ -1629,7 +1629,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
while (rc == -EAGAIN) { while (rc == -EAGAIN) {
if ((open_file->invalidHandle) && if ((open_file->invalidHandle) &&
(!open_file->closePend)) { (!open_file->closePend)) {
rc = cifs_reopen_file(file->f_dentry->d_inode, rc = cifs_reopen_file(file->f_path.dentry->d_inode,
file, TRUE); file, TRUE);
if (rc != 0) if (rc != 0)
break; break;
@ -1658,7 +1658,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma) int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{ {
struct dentry *dentry = file->f_dentry; struct dentry *dentry = file->f_path.dentry;
int rc, xid; int rc, xid;
xid = GetXid(); xid = GetXid();
@ -1744,7 +1744,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
return -EBADF; return -EBADF;
} }
open_file = (struct cifsFileInfo *)file->private_data; open_file = (struct cifsFileInfo *)file->private_data;
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
pagevec_init(&lru_pvec, 0); pagevec_init(&lru_pvec, 0);
@ -1786,7 +1786,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
while (rc == -EAGAIN) { while (rc == -EAGAIN) {
if ((open_file->invalidHandle) && if ((open_file->invalidHandle) &&
(!open_file->closePend)) { (!open_file->closePend)) {
rc = cifs_reopen_file(file->f_dentry->d_inode, rc = cifs_reopen_file(file->f_path.dentry->d_inode,
file, TRUE); file, TRUE);
if (rc != 0) if (rc != 0)
break; break;
@ -1880,8 +1880,8 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
else else
cFYI(1, ("Bytes read %d",rc)); cFYI(1, ("Bytes read %d",rc));
file->f_dentry->d_inode->i_atime = file->f_path.dentry->d_inode->i_atime =
current_fs_time(file->f_dentry->d_inode->i_sb); current_fs_time(file->f_path.dentry->d_inode->i_sb);
if (PAGE_CACHE_SIZE > rc) if (PAGE_CACHE_SIZE > rc)
memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc); memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);

32
fs/cifs/readdir.c
View file

@ -68,30 +68,30 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
int rc = 0; int rc = 0;
cFYI(1, ("For %s", qstring->name)); cFYI(1, ("For %s", qstring->name));
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
qstring->hash = full_name_hash(qstring->name, qstring->len); qstring->hash = full_name_hash(qstring->name, qstring->len);
tmp_dentry = d_lookup(file->f_dentry, qstring); tmp_dentry = d_lookup(file->f_path.dentry, qstring);
if (tmp_dentry) { if (tmp_dentry) {
cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode)); cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
*ptmp_inode = tmp_dentry->d_inode; *ptmp_inode = tmp_dentry->d_inode;
/* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/ /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
if(*ptmp_inode == NULL) { if(*ptmp_inode == NULL) {
*ptmp_inode = new_inode(file->f_dentry->d_sb); *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
if(*ptmp_inode == NULL) if(*ptmp_inode == NULL)
return rc; return rc;
rc = 1; rc = 1;
} }
} else { } else {
tmp_dentry = d_alloc(file->f_dentry, qstring); tmp_dentry = d_alloc(file->f_path.dentry, qstring);
if(tmp_dentry == NULL) { if(tmp_dentry == NULL) {
cERROR(1,("Failed allocating dentry")); cERROR(1,("Failed allocating dentry"));
*ptmp_inode = NULL; *ptmp_inode = NULL;
return rc; return rc;
} }
*ptmp_inode = new_inode(file->f_dentry->d_sb); *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
if (pTcon->nocase) if (pTcon->nocase)
tmp_dentry->d_op = &cifs_ci_dentry_ops; tmp_dentry->d_op = &cifs_ci_dentry_ops;
else else
@ -432,10 +432,10 @@ static int initiate_cifs_search(const int xid, struct file *file)
cifsFile->invalidHandle = TRUE; cifsFile->invalidHandle = TRUE;
cifsFile->srch_inf.endOfSearch = FALSE; cifsFile->srch_inf.endOfSearch = FALSE;
if(file->f_dentry == NULL) if(file->f_path.dentry == NULL)
return -ENOENT; return -ENOENT;
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
if(cifs_sb == NULL) if(cifs_sb == NULL)
return -EINVAL; return -EINVAL;
@ -443,7 +443,7 @@ static int initiate_cifs_search(const int xid, struct file *file)
if(pTcon == NULL) if(pTcon == NULL)
return -EINVAL; return -EINVAL;
full_path = build_path_from_dentry(file->f_dentry); full_path = build_path_from_dentry(file->f_path.dentry);
if(full_path == NULL) { if(full_path == NULL) {
return -ENOMEM; return -ENOMEM;
@ -609,10 +609,10 @@ static int is_dir_changed(struct file * file)
struct inode * inode; struct inode * inode;
struct cifsInodeInfo *cifsInfo; struct cifsInodeInfo *cifsInfo;
if(file->f_dentry == NULL) if(file->f_path.dentry == NULL)
return 0; return 0;
inode = file->f_dentry->d_inode; inode = file->f_path.dentry->d_inode;
if(inode == NULL) if(inode == NULL)
return 0; return 0;
@ -839,7 +839,7 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL)) if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
return -ENOENT; return -ENOENT;
if(file->f_dentry == NULL) if(file->f_path.dentry == NULL)
return -ENOENT; return -ENOENT;
rc = cifs_entry_is_dot(pfindEntry,pCifsF); rc = cifs_entry_is_dot(pfindEntry,pCifsF);
@ -847,7 +847,7 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
if(rc != 0) if(rc != 0)
return 0; return 0;
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
qstring.name = scratch_buf; qstring.name = scratch_buf;
rc = cifs_get_name_from_search_buf(&qstring,pfindEntry, rc = cifs_get_name_from_search_buf(&qstring,pfindEntry,
@ -985,12 +985,12 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
xid = GetXid(); xid = GetXid();
if(file->f_dentry == NULL) { if(file->f_path.dentry == NULL) {
FreeXid(xid); FreeXid(xid);
return -EIO; return -EIO;
} }
cifs_sb = CIFS_SB(file->f_dentry->d_sb); cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
pTcon = cifs_sb->tcon; pTcon = cifs_sb->tcon;
if(pTcon == NULL) if(pTcon == NULL)
return -EINVAL; return -EINVAL;
@ -998,7 +998,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
switch ((int) file->f_pos) { switch ((int) file->f_pos) {
case 0: case 0:
if (filldir(direntry, ".", 1, file->f_pos, if (filldir(direntry, ".", 1, file->f_pos,
file->f_dentry->d_inode->i_ino, DT_DIR) < 0) { file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
cERROR(1, ("Filldir for current dir failed")); cERROR(1, ("Filldir for current dir failed"));
rc = -ENOMEM; rc = -ENOMEM;
break; break;
@ -1006,7 +1006,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
file->f_pos++; file->f_pos++;
case 1: case 1:
if (filldir(direntry, "..", 2, file->f_pos, if (filldir(direntry, "..", 2, file->f_pos,
file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) { file->f_path.dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
cERROR(1, ("Filldir for parent dir failed")); cERROR(1, ("Filldir for parent dir failed"));
rc = -ENOMEM; rc = -ENOMEM;
break; break;