2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* fs/cifs/dir.c
|
|
|
|
*
|
|
|
|
* vfs operations that deal with dentries
|
2007-06-05 11:30:44 -07:00
|
|
|
*
|
2009-02-19 21:32:45 -07:00
|
|
|
* Copyright (C) International Business Machines Corp., 2002,2009
|
2005-04-16 15:20:36 -07:00
|
|
|
* Author(s): Steve French (sfrench@us.ibm.com)
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Lesser General Public License as published
|
|
|
|
* by the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
|
|
* the GNU Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
|
|
* along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/namei.h>
|
2009-09-21 03:47:50 -07:00
|
|
|
#include <linux/mount.h>
|
2010-06-16 10:40:16 -07:00
|
|
|
#include <linux/file.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include "cifsfs.h"
|
|
|
|
#include "cifspdu.h"
|
|
|
|
#include "cifsglob.h"
|
|
|
|
#include "cifsproto.h"
|
|
|
|
#include "cifs_debug.h"
|
|
|
|
#include "cifs_fs_sb.h"
|
|
|
|
|
2007-02-26 22:35:17 -07:00
|
|
|
static void
|
2005-04-16 15:20:36 -07:00
|
|
|
renew_parental_timestamps(struct dentry *direntry)
|
|
|
|
{
|
2007-06-05 11:30:44 -07:00
|
|
|
/* BB check if there is a way to get the kernel to do this or if we
|
|
|
|
really need this */
|
2005-04-16 15:20:36 -07:00
|
|
|
do {
|
|
|
|
direntry->d_time = jiffies;
|
|
|
|
direntry = direntry->d_parent;
|
2007-06-05 11:30:44 -07:00
|
|
|
} while (!IS_ROOT(direntry));
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Note: caller must free return buffer */
|
|
|
|
char *
|
|
|
|
build_path_from_dentry(struct dentry *direntry)
|
|
|
|
{
|
|
|
|
struct dentry *temp;
|
2006-09-21 00:02:52 -07:00
|
|
|
int namelen;
|
|
|
|
int pplen;
|
2008-05-14 18:50:56 -07:00
|
|
|
int dfsplen;
|
2005-04-16 15:20:36 -07:00
|
|
|
char *full_path;
|
2006-03-09 15:21:45 -07:00
|
|
|
char dirsep;
|
2010-09-20 16:01:35 -07:00
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
|
|
|
|
struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
if (direntry == NULL)
|
2005-04-16 15:20:36 -07:00
|
|
|
return NULL; /* not much we can do if dentry is freed and
|
|
|
|
we need to reopen the file after it was closed implicitly
|
|
|
|
when the server crashed */
|
|
|
|
|
2008-05-14 18:50:56 -07:00
|
|
|
dirsep = CIFS_DIR_SEP(cifs_sb);
|
|
|
|
pplen = cifs_sb->prepathlen;
|
2010-09-20 16:01:35 -07:00
|
|
|
if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
|
|
|
|
dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
|
2008-05-14 18:50:56 -07:00
|
|
|
else
|
|
|
|
dfsplen = 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
cifs_bp_rename_retry:
|
2008-05-14 18:50:56 -07:00
|
|
|
namelen = pplen + dfsplen;
|
2005-04-16 15:20:36 -07:00
|
|
|
for (temp = direntry; !IS_ROOT(temp);) {
|
|
|
|
namelen += (1 + temp->d_name.len);
|
|
|
|
temp = temp->d_parent;
|
2007-06-05 11:30:44 -07:00
|
|
|
if (temp == NULL) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cERROR(1, "corrupt dentry");
|
2005-04-16 15:20:36 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
full_path = kmalloc(namelen+1, GFP_KERNEL);
|
2007-06-05 11:30:44 -07:00
|
|
|
if (full_path == NULL)
|
2005-04-16 15:20:36 -07:00
|
|
|
return full_path;
|
|
|
|
full_path[namelen] = 0; /* trailing null */
|
|
|
|
for (temp = direntry; !IS_ROOT(temp);) {
|
|
|
|
namelen -= 1 + temp->d_name.len;
|
|
|
|
if (namelen < 0) {
|
|
|
|
break;
|
|
|
|
} else {
|
2005-08-30 11:32:14 -07:00
|
|
|
full_path[namelen] = dirsep;
|
2005-04-16 15:20:36 -07:00
|
|
|
strncpy(full_path + namelen + 1, temp->d_name.name,
|
|
|
|
temp->d_name.len);
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(0, "name: %s", full_path + namelen);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
temp = temp->d_parent;
|
2007-06-05 11:30:44 -07:00
|
|
|
if (temp == NULL) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cERROR(1, "corrupt dentry");
|
2005-04-16 15:20:36 -07:00
|
|
|
kfree(full_path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-05-14 18:50:56 -07:00
|
|
|
if (namelen != pplen + dfsplen) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cERROR(1, "did not end path lookup where expected namelen is %d",
|
|
|
|
namelen);
|
2007-06-05 11:30:44 -07:00
|
|
|
/* presumably this is only possible if racing with a rename
|
2005-04-16 15:20:36 -07:00
|
|
|
of one of the parent directories (we can not lock the dentries
|
|
|
|
above us to prevent this, but retrying should be harmless) */
|
|
|
|
kfree(full_path);
|
|
|
|
goto cifs_bp_rename_retry;
|
|
|
|
}
|
2006-09-21 00:02:52 -07:00
|
|
|
/* DIR_SEP already set for byte 0 / vs \ but not for
|
|
|
|
subsequent slashes in prepath which currently must
|
|
|
|
be entered the right way - not sure if there is an alternative
|
|
|
|
since the '\' is a valid posix character so we can not switch
|
|
|
|
those safely to '/' if any are found in the middle of the prepath */
|
|
|
|
/* BB test paths to Windows with '/' in the midst of prepath */
|
2008-05-14 18:50:56 -07:00
|
|
|
|
|
|
|
if (dfsplen) {
|
2010-09-20 16:01:35 -07:00
|
|
|
strncpy(full_path, tcon->treeName, dfsplen);
|
2008-05-14 18:50:56 -07:00
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < dfsplen; i++) {
|
|
|
|
if (full_path[i] == '\\')
|
|
|
|
full_path[i] = '/';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
|
2005-04-16 15:20:36 -07:00
|
|
|
return full_path;
|
|
|
|
}
|
|
|
|
|
2006-05-31 15:40:51 -07:00
|
|
|
/* Inode operations in similar order to how they appear in Linux file fs.h */
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
int
|
|
|
|
cifs_create(struct inode *inode, struct dentry *direntry, int mode,
|
|
|
|
struct nameidata *nd)
|
|
|
|
{
|
|
|
|
int rc = -ENOENT;
|
|
|
|
int xid;
|
2008-05-09 15:28:02 -07:00
|
|
|
int create_options = CREATE_NOT_DIR;
|
2009-09-12 08:54:28 -07:00
|
|
|
__u32 oplock = 0;
|
2009-02-19 21:32:45 -07:00
|
|
|
int oflags;
|
|
|
|
/*
|
|
|
|
* BB below access is probably too much for mknod to request
|
|
|
|
* but we have to do query and setpathinfo so requesting
|
|
|
|
* less could fail (unless we want to request getatr and setatr
|
|
|
|
* permissions (only). At least for POSIX we do not have to
|
|
|
|
* request so much.
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
int desiredAccess = GENERIC_READ | GENERIC_WRITE;
|
|
|
|
__u16 fileHandle;
|
|
|
|
struct cifs_sb_info *cifs_sb;
|
2010-09-29 16:51:11 -07:00
|
|
|
struct tcon_link *tlink;
|
2009-01-18 19:38:35 -07:00
|
|
|
struct cifsTconInfo *tcon;
|
2005-04-16 15:20:36 -07:00
|
|
|
char *full_path = NULL;
|
2007-07-09 18:16:18 -07:00
|
|
|
FILE_ALL_INFO *buf = NULL;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct inode *newinode = NULL;
|
|
|
|
int disposition = FILE_OVERWRITE_IF;
|
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(inode->i_sb);
|
2010-09-29 16:51:11 -07:00
|
|
|
tlink = cifs_sb_tlink(cifs_sb);
|
|
|
|
if (IS_ERR(tlink)) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return PTR_ERR(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2010-09-29 16:51:11 -07:00
|
|
|
tcon = tlink_tcon(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
if (oplockEnabled)
|
|
|
|
oplock = REQ_OPLOCK;
|
2009-01-18 19:38:35 -07:00
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
if (nd && (nd->flags & LOOKUP_OPEN))
|
2010-10-15 12:33:56 -07:00
|
|
|
oflags = nd->intent.open.file->f_flags;
|
2009-02-19 21:32:45 -07:00
|
|
|
else
|
2010-10-15 12:33:56 -07:00
|
|
|
oflags = O_RDONLY | O_CREAT;
|
2009-02-19 21:32:45 -07:00
|
|
|
|
2010-09-29 16:51:11 -07:00
|
|
|
full_path = build_path_from_dentry(direntry);
|
|
|
|
if (full_path == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cifs_create_out;
|
|
|
|
}
|
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
|
|
|
|
(CIFS_UNIX_POSIX_PATH_OPS_CAP &
|
|
|
|
le64_to_cpu(tcon->fsUnixInfo.Capability))) {
|
2010-04-22 12:21:55 -07:00
|
|
|
rc = cifs_posix_open(full_path, &newinode,
|
|
|
|
inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
|
2009-02-19 21:32:45 -07:00
|
|
|
/* EIO could indicate that (posix open) operation is not
|
|
|
|
supported, despite what server claimed in capability
|
2011-03-30 18:57:33 -07:00
|
|
|
negotiation. EREMOTE indicates DFS junction, which is not
|
2009-02-19 21:32:45 -07:00
|
|
|
handled in posix open */
|
|
|
|
|
2009-05-07 20:04:30 -07:00
|
|
|
if (rc == 0) {
|
|
|
|
if (newinode == NULL) /* query inode info */
|
|
|
|
goto cifs_create_get_file_info;
|
|
|
|
else /* success, no need to query */
|
|
|
|
goto cifs_create_set_dentry;
|
|
|
|
} else if ((rc != -EIO) && (rc != -EREMOTE) &&
|
2009-05-21 15:21:53 -07:00
|
|
|
(rc != -EOPNOTSUPP) && (rc != -EINVAL))
|
2009-02-19 21:32:45 -07:00
|
|
|
goto cifs_create_out;
|
|
|
|
/* else fallthrough to retry, using older open call, this is
|
|
|
|
case where server does not support this SMB level, and
|
|
|
|
falsely claims capability (also get here for DFS case
|
|
|
|
which should be rare for path not covered on files) */
|
|
|
|
}
|
2005-09-06 15:18:26 -07:00
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
if (nd && (nd->flags & LOOKUP_OPEN)) {
|
|
|
|
/* if the file is going to stay open, then we
|
|
|
|
need to set the desired access properly */
|
2005-09-06 15:18:26 -07:00
|
|
|
desiredAccess = 0;
|
2010-10-15 12:33:56 -07:00
|
|
|
if (OPEN_FMODE(oflags) & FMODE_READ)
|
2009-02-19 21:32:45 -07:00
|
|
|
desiredAccess |= GENERIC_READ; /* is this too little? */
|
2010-10-15 12:33:56 -07:00
|
|
|
if (OPEN_FMODE(oflags) & FMODE_WRITE)
|
2005-09-06 15:18:26 -07:00
|
|
|
desiredAccess |= GENERIC_WRITE;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
|
2005-04-16 15:20:36 -07:00
|
|
|
disposition = FILE_CREATE;
|
2007-06-05 11:30:44 -07:00
|
|
|
else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
|
2005-04-16 15:20:36 -07:00
|
|
|
disposition = FILE_OVERWRITE_IF;
|
2007-06-05 11:30:44 -07:00
|
|
|
else if ((oflags & O_CREAT) == O_CREAT)
|
2005-04-16 15:20:36 -07:00
|
|
|
disposition = FILE_OPEN_IF;
|
2008-02-07 16:25:02 -07:00
|
|
|
else
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "Create flag not set in create function");
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
/* BB add processing to set equivalent of mode - e.g. via CreateX with
|
|
|
|
ACLs */
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
|
|
|
|
if (buf == NULL) {
|
2010-08-05 10:58:38 -07:00
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cifs_create_out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2008-05-09 15:28:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if we're not using unix extensions, see if we need to set
|
|
|
|
* ATTR_READONLY on the create call
|
|
|
|
*/
|
2009-01-18 19:38:35 -07:00
|
|
|
if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
|
2008-05-09 15:28:02 -07:00
|
|
|
create_options |= CREATE_OPTION_READONLY;
|
|
|
|
|
2010-09-20 16:01:33 -07:00
|
|
|
if (tcon->ses->capabilities & CAP_NT_SMBS)
|
2009-01-18 19:38:35 -07:00
|
|
|
rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
|
2008-05-09 15:28:02 -07:00
|
|
|
desiredAccess, create_options,
|
2005-04-28 22:41:06 -07:00
|
|
|
&fileHandle, &oplock, buf, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2006-06-06 17:18:43 -07:00
|
|
|
else
|
|
|
|
rc = -EIO; /* no NT SMB support fall into legacy open below */
|
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
if (rc == -EIO) {
|
2005-08-24 23:06:05 -07:00
|
|
|
/* old server, retry the open legacy style */
|
2009-01-18 19:38:35 -07:00
|
|
|
rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
|
2008-05-09 15:28:02 -07:00
|
|
|
desiredAccess, create_options,
|
2005-08-24 23:06:05 -07:00
|
|
|
&fileHandle, &oplock, buf, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-06-05 11:30:44 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
if (rc) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "cifs_create returned 0x%x", rc);
|
2009-02-19 21:32:45 -07:00
|
|
|
goto cifs_create_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If Open reported that we actually created a file
|
|
|
|
then we now have to set the mode if possible */
|
|
|
|
if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
|
|
|
|
struct cifs_unix_set_info_args args = {
|
2008-08-02 04:26:12 -07:00
|
|
|
.mode = mode,
|
|
|
|
.ctime = NO_CHANGE_64,
|
|
|
|
.atime = NO_CHANGE_64,
|
|
|
|
.mtime = NO_CHANGE_64,
|
|
|
|
.device = 0,
|
2009-02-19 21:32:45 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
|
|
|
|
args.uid = (__u64) current_fsuid();
|
|
|
|
if (inode->i_mode & S_ISGID)
|
|
|
|
args.gid = (__u64) inode->i_gid;
|
|
|
|
else
|
|
|
|
args.gid = (__u64) current_fsgid();
|
2007-06-08 07:55:14 -07:00
|
|
|
} else {
|
2009-02-19 21:32:45 -07:00
|
|
|
args.uid = NO_CHANGE_64;
|
|
|
|
args.gid = NO_CHANGE_64;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2011-01-07 09:30:29 -07:00
|
|
|
CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
|
|
|
|
current->tgid);
|
2009-02-19 21:32:45 -07:00
|
|
|
} else {
|
|
|
|
/* BB implement mode setting via Windows security
|
|
|
|
descriptors e.g. */
|
|
|
|
/* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
|
|
|
|
|
|
|
|
/* Could set r/o dos attribute if mode & 0222 == 0 */
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
cifs_create_get_file_info:
|
|
|
|
/* server might mask mode so we have to query for it */
|
|
|
|
if (tcon->unix_ext)
|
|
|
|
rc = cifs_get_inode_info_unix(&newinode, full_path,
|
|
|
|
inode->i_sb, xid);
|
|
|
|
else {
|
|
|
|
rc = cifs_get_inode_info(&newinode, full_path, buf,
|
|
|
|
inode->i_sb, xid, &fileHandle);
|
|
|
|
if (newinode) {
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
|
|
|
|
newinode->i_mode = mode;
|
|
|
|
if ((oplock & CIFS_CREATE_ACTION) &&
|
|
|
|
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
|
|
|
|
newinode->i_uid = current_fsuid();
|
|
|
|
if (inode->i_mode & S_ISGID)
|
|
|
|
newinode->i_gid = inode->i_gid;
|
|
|
|
else
|
|
|
|
newinode->i_gid = current_fsgid();
|
2005-11-29 21:20:10 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2009-02-19 21:32:45 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-02-19 21:32:45 -07:00
|
|
|
cifs_create_set_dentry:
|
|
|
|
if (rc == 0)
|
2010-12-18 09:43:51 -07:00
|
|
|
d_instantiate(direntry, newinode);
|
2009-02-19 21:32:45 -07:00
|
|
|
else
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
|
2009-02-19 21:32:45 -07:00
|
|
|
|
2010-06-16 10:40:16 -07:00
|
|
|
if (newinode && nd && (nd->flags & LOOKUP_OPEN)) {
|
2010-05-10 21:16:46 -07:00
|
|
|
struct cifsFileInfo *pfile_info;
|
2010-06-16 10:40:16 -07:00
|
|
|
struct file *filp;
|
|
|
|
|
|
|
|
filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
|
|
|
|
if (IS_ERR(filp)) {
|
|
|
|
rc = PTR_ERR(filp);
|
|
|
|
CIFSSMBClose(xid, tcon, fileHandle);
|
|
|
|
goto cifs_create_out;
|
|
|
|
}
|
|
|
|
|
2010-10-15 12:33:58 -07:00
|
|
|
pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
|
2010-06-16 10:40:16 -07:00
|
|
|
if (pfile_info == NULL) {
|
|
|
|
fput(filp);
|
|
|
|
CIFSSMBClose(xid, tcon, fileHandle);
|
2010-05-10 21:16:46 -07:00
|
|
|
rc = -ENOMEM;
|
2010-06-16 10:40:16 -07:00
|
|
|
}
|
2010-06-16 10:40:16 -07:00
|
|
|
} else {
|
|
|
|
CIFSSMBClose(xid, tcon, fileHandle);
|
2007-06-05 11:30:44 -07:00
|
|
|
}
|
2010-06-16 10:40:16 -07:00
|
|
|
|
2005-04-28 22:41:05 -07:00
|
|
|
cifs_create_out:
|
|
|
|
kfree(buf);
|
|
|
|
kfree(full_path);
|
2010-09-29 16:51:11 -07:00
|
|
|
cifs_put_tlink(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-06-05 11:30:44 -07:00
|
|
|
int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
|
|
|
|
dev_t device_number)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int rc = -EPERM;
|
|
|
|
int xid;
|
|
|
|
struct cifs_sb_info *cifs_sb;
|
2010-09-29 16:51:11 -07:00
|
|
|
struct tcon_link *tlink;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct cifsTconInfo *pTcon;
|
|
|
|
char *full_path = NULL;
|
2007-07-09 18:16:18 -07:00
|
|
|
struct inode *newinode = NULL;
|
2010-08-05 10:58:22 -07:00
|
|
|
int oplock = 0;
|
|
|
|
u16 fileHandle;
|
|
|
|
FILE_ALL_INFO *buf = NULL;
|
|
|
|
unsigned int bytes_written;
|
|
|
|
struct win_dev *pdev;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if (!old_valid_dev(device_number))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(inode->i_sb);
|
2010-09-29 16:51:11 -07:00
|
|
|
tlink = cifs_sb_tlink(cifs_sb);
|
|
|
|
if (IS_ERR(tlink))
|
|
|
|
return PTR_ERR(tlink);
|
|
|
|
|
|
|
|
pTcon = tlink_tcon(tlink);
|
|
|
|
|
|
|
|
xid = GetXid();
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
full_path = build_path_from_dentry(direntry);
|
2010-08-05 10:58:22 -07:00
|
|
|
if (full_path == NULL) {
|
2005-04-16 15:20:36 -07:00
|
|
|
rc = -ENOMEM;
|
2010-08-05 10:58:22 -07:00
|
|
|
goto mknod_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pTcon->unix_ext) {
|
2008-08-02 04:26:12 -07:00
|
|
|
struct cifs_unix_set_info_args args = {
|
2009-03-29 16:08:22 -07:00
|
|
|
.mode = mode & ~current_umask(),
|
2008-08-02 04:26:12 -07:00
|
|
|
.ctime = NO_CHANGE_64,
|
|
|
|
.atime = NO_CHANGE_64,
|
|
|
|
.mtime = NO_CHANGE_64,
|
|
|
|
.device = device_number,
|
|
|
|
};
|
2007-06-05 11:30:44 -07:00
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
|
2008-11-13 16:38:47 -07:00
|
|
|
args.uid = (__u64) current_fsuid();
|
|
|
|
args.gid = (__u64) current_fsgid();
|
2005-04-16 15:20:36 -07:00
|
|
|
} else {
|
2008-08-02 04:26:12 -07:00
|
|
|
args.uid = NO_CHANGE_64;
|
|
|
|
args.gid = NO_CHANGE_64;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2009-07-09 17:02:49 -07:00
|
|
|
rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
|
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2010-08-05 10:58:22 -07:00
|
|
|
if (rc)
|
|
|
|
goto mknod_out;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2010-08-05 10:58:22 -07:00
|
|
|
rc = cifs_get_inode_info_unix(&newinode, full_path,
|
2007-06-05 11:30:44 -07:00
|
|
|
inode->i_sb, xid);
|
2005-07-21 15:20:28 -07:00
|
|
|
|
2010-08-05 10:58:22 -07:00
|
|
|
if (rc == 0)
|
|
|
|
d_instantiate(direntry, newinode);
|
|
|
|
goto mknod_out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2010-08-05 10:58:22 -07:00
|
|
|
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
|
|
|
|
goto mknod_out;
|
|
|
|
|
|
|
|
|
|
|
|
cFYI(1, "sfu compat create special file");
|
|
|
|
|
|
|
|
buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
|
|
|
|
if (buf == NULL) {
|
|
|
|
kfree(full_path);
|
|
|
|
rc = -ENOMEM;
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
|
|
|
|
rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
|
|
|
|
GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
|
|
|
|
&fileHandle, &oplock, buf, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
if (rc)
|
|
|
|
goto mknod_out;
|
|
|
|
|
|
|
|
/* BB Do not bother to decode buf since no local inode yet to put
|
|
|
|
* timestamps in, but we can reuse it safely */
|
|
|
|
|
|
|
|
pdev = (struct win_dev *)buf;
|
|
|
|
if (S_ISCHR(mode)) {
|
|
|
|
memcpy(pdev->type, "IntxCHR", 8);
|
|
|
|
pdev->major =
|
|
|
|
cpu_to_le64(MAJOR(device_number));
|
|
|
|
pdev->minor =
|
|
|
|
cpu_to_le64(MINOR(device_number));
|
|
|
|
rc = CIFSSMBWrite(xid, pTcon,
|
|
|
|
fileHandle,
|
|
|
|
sizeof(struct win_dev),
|
|
|
|
0, &bytes_written, (char *)pdev,
|
|
|
|
NULL, 0);
|
|
|
|
} else if (S_ISBLK(mode)) {
|
|
|
|
memcpy(pdev->type, "IntxBLK", 8);
|
|
|
|
pdev->major =
|
|
|
|
cpu_to_le64(MAJOR(device_number));
|
|
|
|
pdev->minor =
|
|
|
|
cpu_to_le64(MINOR(device_number));
|
|
|
|
rc = CIFSSMBWrite(xid, pTcon,
|
|
|
|
fileHandle,
|
|
|
|
sizeof(struct win_dev),
|
|
|
|
0, &bytes_written, (char *)pdev,
|
|
|
|
NULL, 0);
|
|
|
|
} /* else if (S_ISFIFO) */
|
|
|
|
CIFSSMBClose(xid, pTcon, fileHandle);
|
|
|
|
d_drop(direntry);
|
|
|
|
|
|
|
|
/* FIXME: add code here to set EAs */
|
|
|
|
|
|
|
|
mknod_out:
|
2005-04-28 22:41:05 -07:00
|
|
|
kfree(full_path);
|
2010-08-05 10:58:22 -07:00
|
|
|
kfree(buf);
|
2005-04-16 15:20:36 -07:00
|
|
|
FreeXid(xid);
|
2010-09-29 16:51:11 -07:00
|
|
|
cifs_put_tlink(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct dentry *
|
2007-06-05 11:30:44 -07:00
|
|
|
cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
|
|
|
|
struct nameidata *nd)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int xid;
|
|
|
|
int rc = 0; /* to get around spurious gcc warning, set to zero here */
|
2009-09-12 08:54:28 -07:00
|
|
|
__u32 oplock = 0;
|
2009-04-08 18:14:32 -07:00
|
|
|
__u16 fileHandle = 0;
|
|
|
|
bool posix_open = false;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct cifs_sb_info *cifs_sb;
|
2010-09-29 16:51:11 -07:00
|
|
|
struct tcon_link *tlink;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct cifsTconInfo *pTcon;
|
2010-06-16 10:40:16 -07:00
|
|
|
struct cifsFileInfo *cfile;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct inode *newInode = NULL;
|
|
|
|
char *full_path = NULL;
|
2009-04-08 18:14:32 -07:00
|
|
|
struct file *filp;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
|
|
|
|
parent_dir_inode, direntry->d_name.name, direntry);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* check whether path exists */
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
|
2010-09-29 16:51:11 -07:00
|
|
|
tlink = cifs_sb_tlink(cifs_sb);
|
|
|
|
if (IS_ERR(tlink)) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return (struct dentry *)tlink;
|
|
|
|
}
|
|
|
|
pTcon = tlink_tcon(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-04-21 11:18:37 -07:00
|
|
|
/*
|
|
|
|
* Don't allow the separator character in a path component.
|
|
|
|
* The VFS will not allow "/", but "\" is allowed by posix.
|
|
|
|
*/
|
|
|
|
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < direntry->d_name.len; i++)
|
|
|
|
if (direntry->d_name.name[i] == '\\') {
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "Invalid file name");
|
2010-09-29 16:51:11 -07:00
|
|
|
rc = -EINVAL;
|
|
|
|
goto lookup_out;
|
2006-04-21 11:18:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-05 08:01:02 -07:00
|
|
|
/*
|
|
|
|
* O_EXCL: optimize away the lookup, but don't hash the dentry. Let
|
|
|
|
* the VFS handle the create.
|
|
|
|
*/
|
2009-11-24 15:17:59 -07:00
|
|
|
if (nd && (nd->flags & LOOKUP_EXCL)) {
|
2009-07-05 08:01:02 -07:00
|
|
|
d_instantiate(direntry, NULL);
|
2010-09-29 16:51:11 -07:00
|
|
|
rc = 0;
|
|
|
|
goto lookup_out;
|
2009-07-05 08:01:02 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/* can not grab the rename sem here since it would
|
|
|
|
deadlock in the cases (beginning of sys_rename itself)
|
|
|
|
in which we already have the sb rename sem */
|
|
|
|
full_path = build_path_from_dentry(direntry);
|
2007-06-05 11:30:44 -07:00
|
|
|
if (full_path == NULL) {
|
2010-09-29 16:51:11 -07:00
|
|
|
rc = -ENOMEM;
|
|
|
|
goto lookup_out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (direntry->d_inode != NULL) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "non-NULL inode in lookup");
|
2005-04-16 15:20:36 -07:00
|
|
|
} else {
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "NULL inode in lookup");
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[CIFS] Avoid open on possible directories since Samba now rejects them
Small change (mostly formatting) to limit lookup based open calls to
file create only.
After discussion yesteday on samba-technical about the posix lookup
regression, and looking at a problem with cifs posix open to one
particular Samba version, Jeff and JRA realized that Samba server's
behavior changed in this area (posix open behavior on files vs.
directories). To make this behavior consistent, JRA just made a
fix to Samba server to alter how it handles open of directories (now
returning the equivalent of EISDIR instead of success). Since we don't
know at lookup time whether the inode is a directory or file (and
thus whether posix open will succeed with most current Samba server),
this change avoids the posix open code on lookup open (just issues
posix open on creates). This gets the semantic benefits we want
(atomicity, posix byte range locks, improved write semantics on newly
created files) and file create still is fast, and we avoid the problem
that Jeff noticed yesterday with "openat" (and some open directory
calls) of non-cached directories to one version of Samba server, and
will work with future Samba versions (which include the fix jra just
pushed into Samba server). I confirmed this approach with jra
yesterday and with Shirish today.
Posix open is only called (at lookup time) for file create now.
For opens (rather than creates), because we do not know if it
is a file or directory yet, and current Samba no longer allows
us to do posix open on dirs, we could end up wasting an open call
on what turns out to be a dir. For file opens, we wait to call posix
open till cifs_open. It could be added here (lookup) in the future
but the performance tradeoff of the extra network request when EISDIR
or EACCES is returned would have to be weighed against the 50%
reduction in network traffic in the other paths.
Reviewed-by: Shirish Pargaonkar <shirishp@us.ibm.com>
Tested-by: Jeff Layton <jlayton@redhat.com>
CC: Jeremy Allison <jra@samba.org>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-05-23 11:57:25 -07:00
|
|
|
/* Posix open is only called (at lookup time) for file create now.
|
|
|
|
* For opens (rather than creates), because we do not know if it
|
|
|
|
* is a file or directory yet, and current Samba no longer allows
|
|
|
|
* us to do posix open on dirs, we could end up wasting an open call
|
|
|
|
* on what turns out to be a dir. For file opens, we wait to call posix
|
|
|
|
* open till cifs_open. It could be added here (lookup) in the future
|
|
|
|
* but the performance tradeoff of the extra network request when EISDIR
|
|
|
|
* or EACCES is returned would have to be weighed against the 50%
|
|
|
|
* reduction in network traffic in the other paths.
|
|
|
|
*/
|
2009-04-08 18:14:32 -07:00
|
|
|
if (pTcon->unix_ext) {
|
2009-11-24 15:17:59 -07:00
|
|
|
if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
|
[CIFS] Avoid open on possible directories since Samba now rejects them
Small change (mostly formatting) to limit lookup based open calls to
file create only.
After discussion yesteday on samba-technical about the posix lookup
regression, and looking at a problem with cifs posix open to one
particular Samba version, Jeff and JRA realized that Samba server's
behavior changed in this area (posix open behavior on files vs.
directories). To make this behavior consistent, JRA just made a
fix to Samba server to alter how it handles open of directories (now
returning the equivalent of EISDIR instead of success). Since we don't
know at lookup time whether the inode is a directory or file (and
thus whether posix open will succeed with most current Samba server),
this change avoids the posix open code on lookup open (just issues
posix open on creates). This gets the semantic benefits we want
(atomicity, posix byte range locks, improved write semantics on newly
created files) and file create still is fast, and we avoid the problem
that Jeff noticed yesterday with "openat" (and some open directory
calls) of non-cached directories to one version of Samba server, and
will work with future Samba versions (which include the fix jra just
pushed into Samba server). I confirmed this approach with jra
yesterday and with Shirish today.
Posix open is only called (at lookup time) for file create now.
For opens (rather than creates), because we do not know if it
is a file or directory yet, and current Samba no longer allows
us to do posix open on dirs, we could end up wasting an open call
on what turns out to be a dir. For file opens, we wait to call posix
open till cifs_open. It could be added here (lookup) in the future
but the performance tradeoff of the extra network request when EISDIR
or EACCES is returned would have to be weighed against the 50%
reduction in network traffic in the other paths.
Reviewed-by: Shirish Pargaonkar <shirishp@us.ibm.com>
Tested-by: Jeff Layton <jlayton@redhat.com>
CC: Jeremy Allison <jra@samba.org>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-05-23 11:57:25 -07:00
|
|
|
(nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
|
2010-10-15 12:33:56 -07:00
|
|
|
(nd->intent.open.file->f_flags & O_CREAT)) {
|
2010-06-16 10:40:16 -07:00
|
|
|
rc = cifs_posix_open(full_path, &newInode,
|
2010-04-22 12:21:55 -07:00
|
|
|
parent_dir_inode->i_sb,
|
2009-05-21 15:21:53 -07:00
|
|
|
nd->intent.open.create_mode,
|
2010-10-15 12:33:56 -07:00
|
|
|
nd->intent.open.file->f_flags, &oplock,
|
2009-04-08 18:14:32 -07:00
|
|
|
&fileHandle, xid);
|
[CIFS] Avoid open on possible directories since Samba now rejects them
Small change (mostly formatting) to limit lookup based open calls to
file create only.
After discussion yesteday on samba-technical about the posix lookup
regression, and looking at a problem with cifs posix open to one
particular Samba version, Jeff and JRA realized that Samba server's
behavior changed in this area (posix open behavior on files vs.
directories). To make this behavior consistent, JRA just made a
fix to Samba server to alter how it handles open of directories (now
returning the equivalent of EISDIR instead of success). Since we don't
know at lookup time whether the inode is a directory or file (and
thus whether posix open will succeed with most current Samba server),
this change avoids the posix open code on lookup open (just issues
posix open on creates). This gets the semantic benefits we want
(atomicity, posix byte range locks, improved write semantics on newly
created files) and file create still is fast, and we avoid the problem
that Jeff noticed yesterday with "openat" (and some open directory
calls) of non-cached directories to one version of Samba server, and
will work with future Samba versions (which include the fix jra just
pushed into Samba server). I confirmed this approach with jra
yesterday and with Shirish today.
Posix open is only called (at lookup time) for file create now.
For opens (rather than creates), because we do not know if it
is a file or directory yet, and current Samba no longer allows
us to do posix open on dirs, we could end up wasting an open call
on what turns out to be a dir. For file opens, we wait to call posix
open till cifs_open. It could be added here (lookup) in the future
but the performance tradeoff of the extra network request when EISDIR
or EACCES is returned would have to be weighed against the 50%
reduction in network traffic in the other paths.
Reviewed-by: Shirish Pargaonkar <shirishp@us.ibm.com>
Tested-by: Jeff Layton <jlayton@redhat.com>
CC: Jeremy Allison <jra@samba.org>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-05-23 11:57:25 -07:00
|
|
|
/*
|
|
|
|
* The check below works around a bug in POSIX
|
|
|
|
* open in samba versions 3.3.1 and earlier where
|
|
|
|
* open could incorrectly fail with invalid parameter.
|
|
|
|
* If either that or op not supported returned, follow
|
|
|
|
* the normal lookup.
|
|
|
|
*/
|
|
|
|
if ((rc == 0) || (rc == -ENOENT))
|
|
|
|
posix_open = true;
|
|
|
|
else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
|
|
|
|
pTcon->broken_posix_open = true;
|
2009-04-08 18:14:32 -07:00
|
|
|
}
|
|
|
|
if (!posix_open)
|
|
|
|
rc = cifs_get_inode_info_unix(&newInode, full_path,
|
|
|
|
parent_dir_inode->i_sb, xid);
|
|
|
|
} else
|
2005-04-16 15:20:36 -07:00
|
|
|
rc = cifs_get_inode_info(&newInode, full_path, NULL,
|
2009-04-08 18:14:32 -07:00
|
|
|
parent_dir_inode->i_sb, xid, NULL);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if ((rc == 0) && (newInode != NULL)) {
|
|
|
|
d_add(direntry, newInode);
|
2010-06-16 10:40:16 -07:00
|
|
|
if (posix_open) {
|
2010-06-16 10:40:16 -07:00
|
|
|
filp = lookup_instantiate_filp(nd, direntry,
|
|
|
|
generic_file_open);
|
|
|
|
if (IS_ERR(filp)) {
|
|
|
|
rc = PTR_ERR(filp);
|
|
|
|
CIFSSMBClose(xid, pTcon, fileHandle);
|
|
|
|
goto lookup_out;
|
|
|
|
}
|
|
|
|
|
2010-10-15 12:33:58 -07:00
|
|
|
cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
|
|
|
|
oplock);
|
2010-06-16 10:40:16 -07:00
|
|
|
if (cfile == NULL) {
|
2010-06-16 10:40:16 -07:00
|
|
|
fput(filp);
|
2010-06-16 10:40:16 -07:00
|
|
|
CIFSSMBClose(xid, pTcon, fileHandle);
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto lookup_out;
|
|
|
|
}
|
|
|
|
}
|
2007-06-05 11:30:44 -07:00
|
|
|
/* since paths are not looked up by component - the parent
|
2005-11-28 09:16:13 -07:00
|
|
|
directories are presumed to be good here */
|
2005-04-16 15:20:36 -07:00
|
|
|
renew_parental_timestamps(direntry);
|
|
|
|
|
|
|
|
} else if (rc == -ENOENT) {
|
|
|
|
rc = 0;
|
2005-11-28 09:16:13 -07:00
|
|
|
direntry->d_time = jiffies;
|
2005-04-16 15:20:36 -07:00
|
|
|
d_add(direntry, NULL);
|
2007-06-05 11:30:44 -07:00
|
|
|
/* if it was once a directory (but how can we tell?) we could do
|
|
|
|
shrink_dcache_parent(direntry); */
|
2008-01-19 17:30:29 -07:00
|
|
|
} else if (rc != -EACCES) {
|
2010-04-20 20:50:45 -07:00
|
|
|
cERROR(1, "Unexpected lookup error %d", rc);
|
2008-01-19 17:30:29 -07:00
|
|
|
/* We special case check for Access Denied - since that
|
|
|
|
is a common return code */
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2010-06-16 10:40:16 -07:00
|
|
|
lookup_out:
|
2005-04-28 22:41:05 -07:00
|
|
|
kfree(full_path);
|
2010-09-29 16:51:11 -07:00
|
|
|
cifs_put_tlink(tlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
FreeXid(xid);
|
|
|
|
return ERR_PTR(rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
|
|
|
|
{
|
2011-01-06 23:49:57 -07:00
|
|
|
if (nd->flags & LOOKUP_RCU)
|
|
|
|
return -ECHILD;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
if (direntry->d_inode) {
|
2010-02-12 05:44:16 -07:00
|
|
|
if (cifs_revalidate_dentry(direntry))
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
2010-11-11 00:42:16 -07:00
|
|
|
else
|
|
|
|
return 1;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2010-11-11 00:42:16 -07:00
|
|
|
/*
|
|
|
|
* This may be nfsd (or something), anyway, we can't see the
|
|
|
|
* intent of this. So, since this can be for creation, drop it.
|
|
|
|
*/
|
|
|
|
if (!nd)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop the negative dentry, in order to make sure to use the
|
|
|
|
* case sensitive name which is specified by user if this is
|
|
|
|
* for creation.
|
|
|
|
*/
|
|
|
|
if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
|
|
|
|
if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* static int cifs_d_delete(struct dentry *direntry)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
2010-04-20 20:50:45 -07:00
|
|
|
cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
} */
|
|
|
|
|
2009-02-19 22:57:07 -07:00
|
|
|
const struct dentry_operations cifs_dentry_ops = {
|
2005-04-16 15:20:36 -07:00
|
|
|
.d_revalidate = cifs_d_revalidate,
|
2011-01-14 11:45:47 -07:00
|
|
|
.d_automount = cifs_dfs_d_automount,
|
2007-06-05 11:30:44 -07:00
|
|
|
/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
2005-08-22 20:09:43 -07:00
|
|
|
|
2011-01-06 23:49:28 -07:00
|
|
|
static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
|
|
|
|
struct qstr *q)
|
2005-08-22 20:09:43 -07:00
|
|
|
{
|
2011-01-06 23:49:28 -07:00
|
|
|
struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
|
2005-08-22 20:09:43 -07:00
|
|
|
unsigned long hash;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
hash = init_name_hash();
|
|
|
|
for (i = 0; i < q->len; i++)
|
|
|
|
hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
|
|
|
|
hash);
|
|
|
|
q->hash = end_name_hash(hash);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-06 23:49:27 -07:00
|
|
|
static int cifs_ci_compare(const struct dentry *parent,
|
|
|
|
const struct inode *pinode,
|
|
|
|
const struct dentry *dentry, const struct inode *inode,
|
|
|
|
unsigned int len, const char *str, const struct qstr *name)
|
2005-08-22 20:09:43 -07:00
|
|
|
{
|
2011-01-06 23:49:27 -07:00
|
|
|
struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
|
2005-08-22 20:09:43 -07:00
|
|
|
|
2011-01-06 23:49:27 -07:00
|
|
|
if ((name->len == len) &&
|
|
|
|
(nls_strnicmp(codepage, name->name, str, len) == 0))
|
2005-08-22 20:09:43 -07:00
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-02-19 22:57:07 -07:00
|
|
|
const struct dentry_operations cifs_ci_dentry_ops = {
|
2005-08-22 20:09:43 -07:00
|
|
|
.d_revalidate = cifs_d_revalidate,
|
|
|
|
.d_hash = cifs_ci_hash,
|
|
|
|
.d_compare = cifs_ci_compare,
|
2011-01-14 11:45:47 -07:00
|
|
|
.d_automount = cifs_dfs_d_automount,
|
2005-08-22 20:09:43 -07:00
|
|
|
};
|