2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* fs/cifs/inode.c
|
|
|
|
*
|
2008-12-06 02:14:12 +07:00
|
|
|
* Copyright (C) International Business Machines Corp., 2002,2008
|
2005-04-17 05: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/pagemap.h>
|
|
|
|
#include <asm/div64.h>
|
|
|
|
#include "cifsfs.h"
|
|
|
|
#include "cifspdu.h"
|
|
|
|
#include "cifsglob.h"
|
|
|
|
#include "cifsproto.h"
|
|
|
|
#include "cifs_debug.h"
|
|
|
|
#include "cifs_fs_sb.h"
|
|
|
|
|
2008-02-16 03:55:05 +07:00
|
|
|
|
2008-03-09 10:44:18 +07:00
|
|
|
static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
|
2008-02-16 03:55:05 +07:00
|
|
|
{
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
|
|
|
|
switch (inode->i_mode & S_IFMT) {
|
|
|
|
case S_IFREG:
|
|
|
|
inode->i_op = &cifs_file_inode_ops;
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
|
|
|
|
inode->i_fop = &cifs_file_direct_nobrl_ops;
|
|
|
|
else
|
|
|
|
inode->i_fop = &cifs_file_direct_ops;
|
|
|
|
} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
|
|
|
|
inode->i_fop = &cifs_file_nobrl_ops;
|
|
|
|
else { /* not direct, send byte range locks */
|
|
|
|
inode->i_fop = &cifs_file_ops;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* check if server can support readpages */
|
|
|
|
if (cifs_sb->tcon->ses->server->maxBuf <
|
|
|
|
PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
|
|
|
|
inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
|
|
|
|
else
|
|
|
|
inode->i_data.a_ops = &cifs_addr_ops;
|
|
|
|
break;
|
|
|
|
case S_IFDIR:
|
2008-03-12 04:07:48 +07:00
|
|
|
#ifdef CONFIG_CIFS_DFS_UPCALL
|
2008-03-09 10:44:18 +07:00
|
|
|
if (is_dfs_referral) {
|
|
|
|
inode->i_op = &cifs_dfs_referral_inode_operations;
|
|
|
|
} else {
|
2008-03-12 04:07:48 +07:00
|
|
|
#else /* NO DFS support, treat as a directory */
|
|
|
|
{
|
|
|
|
#endif
|
2008-03-09 10:44:18 +07:00
|
|
|
inode->i_op = &cifs_dir_inode_ops;
|
|
|
|
inode->i_fop = &cifs_dir_ops;
|
|
|
|
}
|
2008-02-16 03:55:05 +07:00
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
|
|
|
inode->i_op = &cifs_symlink_inode_ops;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
init_special_inode(inode, inode->i_mode, inode->i_rdev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-26 03:25:21 +07:00
|
|
|
static void cifs_unix_info_to_inode(struct inode *inode,
|
|
|
|
FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
|
|
|
|
{
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
|
|
|
|
__u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
|
|
|
|
__u64 end_of_file = le64_to_cpu(info->EndOfFile);
|
|
|
|
|
|
|
|
inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
|
|
|
|
inode->i_mtime =
|
|
|
|
cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
|
|
|
|
inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
|
|
|
|
inode->i_mode = le64_to_cpu(info->Permissions);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we set the inode type below we need to mask off
|
|
|
|
* to avoid strange results if bits set above.
|
|
|
|
*/
|
|
|
|
inode->i_mode &= ~S_IFMT;
|
|
|
|
switch (le32_to_cpu(info->Type)) {
|
|
|
|
case UNIX_FILE:
|
|
|
|
inode->i_mode |= S_IFREG;
|
|
|
|
break;
|
|
|
|
case UNIX_SYMLINK:
|
|
|
|
inode->i_mode |= S_IFLNK;
|
|
|
|
break;
|
|
|
|
case UNIX_DIR:
|
|
|
|
inode->i_mode |= S_IFDIR;
|
|
|
|
break;
|
|
|
|
case UNIX_CHARDEV:
|
|
|
|
inode->i_mode |= S_IFCHR;
|
|
|
|
inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
|
|
|
|
le64_to_cpu(info->DevMinor) & MINORMASK);
|
|
|
|
break;
|
|
|
|
case UNIX_BLOCKDEV:
|
|
|
|
inode->i_mode |= S_IFBLK;
|
|
|
|
inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
|
|
|
|
le64_to_cpu(info->DevMinor) & MINORMASK);
|
|
|
|
break;
|
|
|
|
case UNIX_FIFO:
|
|
|
|
inode->i_mode |= S_IFIFO;
|
|
|
|
break;
|
|
|
|
case UNIX_SOCKET:
|
|
|
|
inode->i_mode |= S_IFSOCK;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* safest to call it a file if we do not know */
|
|
|
|
inode->i_mode |= S_IFREG;
|
|
|
|
cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
|
|
|
|
!force_uid_gid)
|
|
|
|
inode->i_uid = cifs_sb->mnt_uid;
|
|
|
|
else
|
|
|
|
inode->i_uid = le64_to_cpu(info->Uid);
|
|
|
|
|
|
|
|
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
|
|
|
|
!force_uid_gid)
|
|
|
|
inode->i_gid = cifs_sb->mnt_gid;
|
|
|
|
else
|
|
|
|
inode->i_gid = le64_to_cpu(info->Gid);
|
|
|
|
|
|
|
|
inode->i_nlink = le64_to_cpu(info->Nlinks);
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (is_size_safe_to_change(cifsInfo, end_of_file)) {
|
|
|
|
/*
|
|
|
|
* We can not safely change the file size here if the client
|
|
|
|
* is writing to it due to potential races.
|
|
|
|
*/
|
|
|
|
i_size_write(inode, end_of_file);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* i_blocks is not related to (i_size / i_blksize),
|
|
|
|
* but instead 512 byte (2**9) size is required for
|
|
|
|
* calculating num blocks.
|
|
|
|
*/
|
|
|
|
inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
|
|
|
|
}
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Needed to setup inode data for the directory which is the
|
|
|
|
* junction to the new submount (ie to setup the fake directory
|
|
|
|
* which represents a DFS referral)
|
|
|
|
*/
|
2008-05-21 02:50:46 +07:00
|
|
|
static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
|
|
|
|
struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct inode *pinode = NULL;
|
|
|
|
|
2008-05-22 21:20:21 +07:00
|
|
|
memset(pfnd_dat, 0, sizeof(FILE_UNIX_BASIC_INFO));
|
2008-05-21 02:50:46 +07:00
|
|
|
|
|
|
|
/* __le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
|
|
|
|
__le64 pfnd_dat->NumOfBytes = cpu_to_le64(0);
|
|
|
|
__u64 UniqueId = 0; */
|
|
|
|
pfnd_dat->LastStatusChange =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->LastAccessTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->LastModificationTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->Type = cpu_to_le32(UNIX_DIR);
|
|
|
|
pfnd_dat->Permissions = cpu_to_le64(S_IXUGO | S_IRWXU);
|
|
|
|
pfnd_dat->Nlinks = cpu_to_le64(2);
|
|
|
|
if (sb->s_root)
|
|
|
|
pinode = sb->s_root->d_inode;
|
|
|
|
if (pinode == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* fill in default values for the remaining based on root
|
|
|
|
inode since we can not query the server for this inode info */
|
|
|
|
pfnd_dat->DevMajor = cpu_to_le64(MAJOR(pinode->i_rdev));
|
|
|
|
pfnd_dat->DevMinor = cpu_to_le64(MINOR(pinode->i_rdev));
|
|
|
|
pfnd_dat->Uid = cpu_to_le64(pinode->i_uid);
|
|
|
|
pfnd_dat->Gid = cpu_to_le64(pinode->i_gid);
|
|
|
|
}
|
|
|
|
|
2009-02-10 19:33:57 +07:00
|
|
|
/**
|
|
|
|
* cifs_new inode - create new inode, initialize, and hash it
|
|
|
|
* @sb - pointer to superblock
|
|
|
|
* @inum - if valid pointer and serverino is enabled, replace i_ino with val
|
|
|
|
*
|
|
|
|
* Create a new inode, initialize it for CIFS and hash it. Returns the new
|
|
|
|
* inode or NULL if one couldn't be allocated.
|
|
|
|
*
|
|
|
|
* If the share isn't mounted with "serverino" or inum is a NULL pointer then
|
|
|
|
* we'll just use the inode number assigned by new_inode(). Note that this can
|
|
|
|
* mean i_ino collisions since the i_ino assigned by new_inode is not
|
|
|
|
* guaranteed to be unique.
|
|
|
|
*/
|
|
|
|
struct inode *
|
2009-02-11 20:08:26 +07:00
|
|
|
cifs_new_inode(struct super_block *sb, __u64 *inum)
|
2009-02-10 19:33:57 +07:00
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
inode = new_inode(sb);
|
|
|
|
if (inode == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* BB: Is i_ino == 0 legal? Here, we assume that it is. If it isn't we
|
|
|
|
* stop passing inum as ptr. Are there sanity checks we can use to
|
|
|
|
* ensure that the server is really filling in that field? Also,
|
|
|
|
* if serverino is disabled, perhaps we should be using iunique()?
|
|
|
|
*/
|
|
|
|
if (inum && (CIFS_SB(sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
|
2009-02-11 20:08:26 +07:00
|
|
|
inode->i_ino = (unsigned long) *inum;
|
2009-02-10 19:33:57 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* must set this here instead of cifs_alloc_inode since VFS will
|
|
|
|
* clobber i_flags
|
|
|
|
*/
|
|
|
|
if (sb->s_flags & MS_NOATIME)
|
|
|
|
inode->i_flags |= S_NOATIME | S_NOCMTIME;
|
|
|
|
|
|
|
|
insert_inode_hash(inode);
|
|
|
|
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int cifs_get_inode_info_unix(struct inode **pinode,
|
2008-05-15 08:50:56 +07:00
|
|
|
const unsigned char *full_path, struct super_block *sb, int xid)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int rc = 0;
|
2008-05-21 02:50:46 +07:00
|
|
|
FILE_UNIX_BASIC_INFO find_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cifsTconInfo *pTcon;
|
|
|
|
struct inode *inode;
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
|
2008-03-09 10:44:18 +07:00
|
|
|
bool is_dfs_referral = false;
|
2008-05-21 02:50:46 +07:00
|
|
|
struct cifsInodeInfo *cifsInfo;
|
|
|
|
__u64 num_of_bytes;
|
|
|
|
__u64 end_of_file;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
pTcon = cifs_sb->tcon;
|
2008-05-15 08:50:56 +07:00
|
|
|
cFYI(1, ("Getting info on %s", full_path));
|
2008-03-09 10:44:18 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* could have done a find first instead but this returns more info */
|
2008-05-21 02:50:46 +07:00
|
|
|
rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &find_data,
|
2005-04-29 12:41:06 +07:00
|
|
|
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-07-13 03:47:59 +07:00
|
|
|
if (rc == -EREMOTE && !is_dfs_referral) {
|
|
|
|
is_dfs_referral = true;
|
|
|
|
cFYI(DBG2, ("DFS ref"));
|
|
|
|
/* for DFS, server does not give us real inode data */
|
|
|
|
fill_fake_finddataunix(&find_data, sb);
|
|
|
|
rc = 0;
|
|
|
|
} else if (rc)
|
|
|
|
goto cgiiu_exit;
|
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
num_of_bytes = le64_to_cpu(find_data.NumOfBytes);
|
|
|
|
end_of_file = le64_to_cpu(find_data.EndOfFile);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
/* get new inode */
|
|
|
|
if (*pinode == NULL) {
|
2009-02-11 20:08:26 +07:00
|
|
|
*pinode = cifs_new_inode(sb, &find_data.UniqueId);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (*pinode == NULL) {
|
2008-05-21 02:50:46 +07:00
|
|
|
rc = -ENOMEM;
|
2008-07-13 03:47:59 +07:00
|
|
|
goto cgiiu_exit;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-05-21 02:50:46 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
inode = *pinode;
|
|
|
|
cifsInfo = CIFS_I(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
cFYI(1, ("Old time %ld", cifsInfo->time));
|
|
|
|
cifsInfo->time = jiffies;
|
|
|
|
cFYI(1, ("New time %ld", cifsInfo->time));
|
|
|
|
/* this is ok to set on every inode revalidate */
|
|
|
|
atomic_set(&cifsInfo->inUse, 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
cifs_unix_info_to_inode(inode, &find_data, 0);
|
2008-02-16 03:55:05 +07:00
|
|
|
|
2008-05-21 02:50:46 +07:00
|
|
|
if (num_of_bytes < end_of_file)
|
|
|
|
cFYI(1, ("allocation size less than end of file"));
|
|
|
|
cFYI(1, ("Size %ld and blocks %llu",
|
|
|
|
(unsigned long) inode->i_size,
|
|
|
|
(unsigned long long)inode->i_blocks));
|
|
|
|
|
|
|
|
cifs_set_ops(inode, is_dfs_referral);
|
2008-03-09 10:44:18 +07:00
|
|
|
cgiiu_exit:
|
2005-04-17 05:20:36 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
static int decode_sfu_inode(struct inode *inode, __u64 size,
|
2005-11-16 07:43:39 +07:00
|
|
|
const unsigned char *path,
|
|
|
|
struct cifs_sb_info *cifs_sb, int xid)
|
|
|
|
{
|
|
|
|
int rc;
|
2008-04-29 07:06:05 +07:00
|
|
|
int oplock = 0;
|
2005-11-16 07:43:39 +07:00
|
|
|
__u16 netfid;
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
2005-11-19 11:25:31 +07:00
|
|
|
char buf[24];
|
2005-11-16 07:43:39 +07:00
|
|
|
unsigned int bytes_read;
|
2007-07-10 08:16:18 +07:00
|
|
|
char *pbuf;
|
2005-11-16 07:43:39 +07:00
|
|
|
|
|
|
|
pbuf = buf;
|
|
|
|
|
2007-05-01 03:13:06 +07:00
|
|
|
if (size == 0) {
|
2005-11-16 07:43:39 +07:00
|
|
|
inode->i_mode |= S_IFIFO;
|
|
|
|
return 0;
|
|
|
|
} else if (size < 8) {
|
|
|
|
return -EINVAL; /* EOPNOTSUPP? */
|
|
|
|
}
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2005-11-16 07:43:39 +07:00
|
|
|
rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
|
|
|
|
CREATE_NOT_DIR, &netfid, &oplock, NULL,
|
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-07-10 08:16:18 +07:00
|
|
|
if (rc == 0) {
|
2005-12-13 11:53:18 +07:00
|
|
|
int buf_type = CIFS_NO_BUFFER;
|
2005-11-16 07:43:39 +07:00
|
|
|
/* Read header */
|
|
|
|
rc = CIFSSMBRead(xid, pTcon,
|
2007-07-10 08:16:18 +07:00
|
|
|
netfid,
|
2005-11-19 11:25:31 +07:00
|
|
|
24 /* length */, 0 /* offset */,
|
2005-12-13 11:53:18 +07:00
|
|
|
&bytes_read, &pbuf, &buf_type);
|
2007-05-01 03:13:06 +07:00
|
|
|
if ((rc == 0) && (bytes_read >= 8)) {
|
|
|
|
if (memcmp("IntxBLK", pbuf, 8) == 0) {
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("Block device"));
|
2005-11-19 02:31:10 +07:00
|
|
|
inode->i_mode |= S_IFBLK;
|
2007-05-01 03:13:06 +07:00
|
|
|
if (bytes_read == 24) {
|
2005-11-19 11:25:31 +07:00
|
|
|
/* we have enough to decode dev num */
|
|
|
|
__u64 mjr; /* major */
|
|
|
|
__u64 mnr; /* minor */
|
|
|
|
mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
|
|
|
|
mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
|
|
|
|
inode->i_rdev = MKDEV(mjr, mnr);
|
|
|
|
}
|
2007-05-01 03:13:06 +07:00
|
|
|
} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("Char device"));
|
2005-11-19 02:31:10 +07:00
|
|
|
inode->i_mode |= S_IFCHR;
|
2007-05-01 03:13:06 +07:00
|
|
|
if (bytes_read == 24) {
|
2005-11-19 11:25:31 +07:00
|
|
|
/* we have enough to decode dev num */
|
|
|
|
__u64 mjr; /* major */
|
|
|
|
__u64 mnr; /* minor */
|
|
|
|
mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
|
|
|
|
mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
|
|
|
|
inode->i_rdev = MKDEV(mjr, mnr);
|
2007-07-10 08:16:18 +07:00
|
|
|
}
|
2007-05-01 03:13:06 +07:00
|
|
|
} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("Symlink"));
|
2005-11-19 02:31:10 +07:00
|
|
|
inode->i_mode |= S_IFLNK;
|
2005-11-19 11:25:31 +07:00
|
|
|
} else {
|
|
|
|
inode->i_mode |= S_IFREG; /* file? */
|
2007-07-10 08:16:18 +07:00
|
|
|
rc = -EOPNOTSUPP;
|
2005-11-19 11:25:31 +07:00
|
|
|
}
|
2005-11-19 02:31:10 +07:00
|
|
|
} else {
|
|
|
|
inode->i_mode |= S_IFREG; /* then it is a file */
|
2007-07-10 08:16:18 +07:00
|
|
|
rc = -EOPNOTSUPP; /* or some unknown SFU type */
|
|
|
|
}
|
2005-11-16 07:43:39 +07:00
|
|
|
CIFSSMBClose(xid, pTcon, netfid);
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-11-18 07:59:21 +07:00
|
|
|
#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
|
|
|
|
|
2007-10-31 11:54:42 +07:00
|
|
|
static int get_sfu_mode(struct inode *inode,
|
2005-11-18 07:59:21 +07:00
|
|
|
const unsigned char *path,
|
|
|
|
struct cifs_sb_info *cifs_sb, int xid)
|
|
|
|
{
|
2005-11-19 02:31:10 +07:00
|
|
|
#ifdef CONFIG_CIFS_XATTR
|
2005-11-18 07:59:21 +07:00
|
|
|
ssize_t rc;
|
|
|
|
char ea_value[4];
|
|
|
|
__u32 mode;
|
|
|
|
|
|
|
|
rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
|
|
|
|
ea_value, 4 /* size of buf */, cifs_sb->local_nls,
|
2007-07-10 08:16:18 +07:00
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-05-01 03:13:06 +07:00
|
|
|
if (rc < 0)
|
2005-11-18 07:59:21 +07:00
|
|
|
return (int)rc;
|
|
|
|
else if (rc > 3) {
|
|
|
|
mode = le32_to_cpu(*((__le32 *)ea_value));
|
2007-07-10 08:16:18 +07:00
|
|
|
inode->i_mode &= ~SFBITS_MASK;
|
|
|
|
cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
|
2005-11-18 07:59:21 +07:00
|
|
|
inode->i_mode = (mode & SFBITS_MASK) | inode->i_mode;
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("special mode bits 0%o", mode));
|
2005-11-18 07:59:21 +07:00
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
2005-11-19 02:31:10 +07:00
|
|
|
#else
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
#endif
|
2005-11-18 07:59:21 +07:00
|
|
|
}
|
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
/*
|
|
|
|
* Needed to setup inode data for the directory which is the
|
|
|
|
* junction to the new submount (ie to setup the fake directory
|
|
|
|
* which represents a DFS referral)
|
|
|
|
*/
|
|
|
|
static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
|
|
|
|
struct super_block *sb)
|
|
|
|
{
|
2008-05-22 21:20:21 +07:00
|
|
|
memset(pfnd_dat, 0, sizeof(FILE_ALL_INFO));
|
2008-05-21 04:52:32 +07:00
|
|
|
|
|
|
|
/* __le64 pfnd_dat->AllocationSize = cpu_to_le64(0);
|
|
|
|
__le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
|
|
|
|
__u8 pfnd_dat->DeletePending = 0;
|
|
|
|
__u8 pfnd_data->Directory = 0;
|
|
|
|
__le32 pfnd_dat->EASize = 0;
|
|
|
|
__u64 pfnd_dat->IndexNumber = 0;
|
|
|
|
__u64 pfnd_dat->IndexNumber1 = 0; */
|
|
|
|
pfnd_dat->CreationTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->LastAccessTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->LastWriteTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->ChangeTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
|
|
|
|
pfnd_dat->Attributes = cpu_to_le32(ATTR_DIRECTORY);
|
|
|
|
pfnd_dat->NumberOfLinks = cpu_to_le32(2);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int cifs_get_inode_info(struct inode **pinode,
|
2008-05-15 08:50:56 +07:00
|
|
|
const unsigned char *full_path, FILE_ALL_INFO *pfindData,
|
2008-03-15 05:37:16 +07:00
|
|
|
struct super_block *sb, int xid, const __u16 *pfid)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int rc = 0;
|
2008-05-21 04:52:32 +07:00
|
|
|
__u32 attr;
|
|
|
|
struct cifsInodeInfo *cifsInfo;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cifsTconInfo *pTcon;
|
|
|
|
struct inode *inode;
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
|
|
|
|
char *buf = NULL;
|
2008-05-03 03:56:23 +07:00
|
|
|
bool adjustTZ = false;
|
2008-03-09 10:44:18 +07:00
|
|
|
bool is_dfs_referral = false;
|
2008-05-22 20:31:40 +07:00
|
|
|
umode_t default_mode;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
pTcon = cifs_sb->tcon;
|
2008-05-15 08:50:56 +07:00
|
|
|
cFYI(1, ("Getting info on %s", full_path));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-03 05:12:36 +07:00
|
|
|
if ((pfindData == NULL) && (*pinode != NULL)) {
|
|
|
|
if (CIFS_I(*pinode)->clientCanCacheRead) {
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("No need to revalidate cached inode sizes"));
|
2005-04-17 05:20:36 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if file info not passed in then get it from server */
|
2005-06-03 05:12:36 +07:00
|
|
|
if (pfindData == NULL) {
|
2005-04-17 05:20:36 +07:00
|
|
|
buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
|
2005-06-03 05:12:36 +07:00
|
|
|
if (buf == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
pfindData = (FILE_ALL_INFO *)buf;
|
2008-03-09 10:44:18 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* could do find first instead but this returns more info */
|
2008-03-09 10:44:18 +07:00
|
|
|
rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
|
2006-10-12 10:28:28 +07:00
|
|
|
0 /* not legacy */,
|
2005-08-24 10:26:03 +07:00
|
|
|
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
|
2005-04-29 12:41:06 +07:00
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2005-08-24 10:26:03 +07:00
|
|
|
/* BB optimize code so we do not make the above call
|
|
|
|
when server claims no NT SMB support and the above call
|
|
|
|
failed at least once - set flag in tcon or mount */
|
2007-05-01 03:13:06 +07:00
|
|
|
if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
|
2008-03-09 10:44:18 +07:00
|
|
|
rc = SMBQueryInformation(xid, pTcon, full_path,
|
2007-07-10 08:16:18 +07:00
|
|
|
pfindData, cifs_sb->local_nls,
|
2005-08-24 10:26:03 +07:00
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-04-29 07:06:05 +07:00
|
|
|
adjustTZ = true;
|
2005-08-24 10:26:03 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
/* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
|
2008-05-21 04:52:32 +07:00
|
|
|
if (rc == -EREMOTE) {
|
|
|
|
is_dfs_referral = true;
|
|
|
|
fill_fake_finddata(pfindData, sb);
|
|
|
|
rc = 0;
|
|
|
|
} else if (rc)
|
2008-03-09 10:44:18 +07:00
|
|
|
goto cgii_exit;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
attr = le32_to_cpu(pfindData->Attributes);
|
|
|
|
|
|
|
|
/* get new inode */
|
|
|
|
if (*pinode == NULL) {
|
2009-02-10 19:33:57 +07:00
|
|
|
__u64 inode_num;
|
2009-02-11 20:08:26 +07:00
|
|
|
__u64 *pinum = &inode_num;
|
2009-02-10 19:33:57 +07:00
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
/* Is an i_ino of zero legal? Can we use that to check
|
|
|
|
if the server supports returning inode numbers? Are
|
|
|
|
there other sanity checks we can use to ensure that
|
|
|
|
the server is really filling in that field? */
|
|
|
|
|
|
|
|
/* We can not use the IndexNumber field by default from
|
|
|
|
Windows or Samba (in ALL_INFO buf) but we can request
|
|
|
|
it explicitly. It may not be unique presumably if
|
|
|
|
the server has multiple devices mounted under one share */
|
|
|
|
|
|
|
|
/* There may be higher info levels that work but are
|
|
|
|
there Windows server or network appliances for which
|
|
|
|
IndexNumber field is not guaranteed unique? */
|
|
|
|
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
|
|
|
|
int rc1 = 0;
|
|
|
|
|
|
|
|
rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
|
2009-02-11 20:08:26 +07:00
|
|
|
full_path, pinum,
|
2005-04-29 12:41:06 +07:00
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-05-21 04:52:32 +07:00
|
|
|
if (rc1) {
|
|
|
|
cFYI(1, ("GetSrvInodeNum rc %d", rc1));
|
2009-02-11 20:08:26 +07:00
|
|
|
pinum = NULL;
|
2008-05-21 04:52:32 +07:00
|
|
|
/* BB EOPNOSUPP disable SERVER_INUM? */
|
2009-02-10 19:33:57 +07:00
|
|
|
}
|
|
|
|
} else {
|
2009-02-11 20:08:26 +07:00
|
|
|
pinum = NULL;
|
2009-02-10 19:33:57 +07:00
|
|
|
}
|
|
|
|
|
2009-02-11 20:08:26 +07:00
|
|
|
*pinode = cifs_new_inode(sb, pinum);
|
2009-02-10 19:33:57 +07:00
|
|
|
if (*pinode == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cgii_exit;
|
|
|
|
}
|
2008-05-21 04:52:32 +07:00
|
|
|
}
|
|
|
|
inode = *pinode;
|
|
|
|
cifsInfo = CIFS_I(inode);
|
|
|
|
cifsInfo->cifsAttrs = attr;
|
2008-10-18 08:03:20 +07:00
|
|
|
cifsInfo->delete_pending = pfindData->DeletePending ? true : false;
|
2008-05-21 04:52:32 +07:00
|
|
|
cFYI(1, ("Old time %ld", cifsInfo->time));
|
|
|
|
cifsInfo->time = jiffies;
|
|
|
|
cFYI(1, ("New time %ld", cifsInfo->time));
|
|
|
|
|
|
|
|
/* blksize needs to be multiple of two. So safer to default to
|
|
|
|
blksize and blkbits set in superblock so 2**blkbits and blksize
|
|
|
|
will match rather than setting to:
|
|
|
|
(pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
|
|
|
|
|
|
|
|
/* Linux can not store file creation time so ignore it */
|
|
|
|
if (pfindData->LastAccessTime)
|
|
|
|
inode->i_atime = cifs_NTtimeToUnix
|
|
|
|
(le64_to_cpu(pfindData->LastAccessTime));
|
|
|
|
else /* do not need to use current_fs_time - time not stored */
|
|
|
|
inode->i_atime = CURRENT_TIME;
|
|
|
|
inode->i_mtime =
|
2005-04-17 05:20:36 +07:00
|
|
|
cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
|
2008-05-21 04:52:32 +07:00
|
|
|
inode->i_ctime =
|
|
|
|
cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
|
|
|
|
cFYI(DBG2, ("Attributes came in as 0x%x", attr));
|
|
|
|
if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
|
|
|
|
inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
|
|
|
|
inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-22 20:31:40 +07:00
|
|
|
/* get default inode mode */
|
|
|
|
if (attr & ATTR_DIRECTORY)
|
|
|
|
default_mode = cifs_sb->mnt_dir_mode;
|
|
|
|
else
|
|
|
|
default_mode = cifs_sb->mnt_file_mode;
|
|
|
|
|
|
|
|
/* set permission bits */
|
|
|
|
if (atomic_read(&cifsInfo->inUse) == 0 ||
|
|
|
|
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
|
|
|
|
inode->i_mode = default_mode;
|
|
|
|
else {
|
|
|
|
/* just reenable write bits if !ATTR_READONLY */
|
|
|
|
if ((inode->i_mode & S_IWUGO) == 0 &&
|
|
|
|
(attr & ATTR_READONLY) == 0)
|
|
|
|
inode->i_mode |= (S_IWUGO & default_mode);
|
2008-08-19 21:23:37 +07:00
|
|
|
|
|
|
|
inode->i_mode &= ~S_IFMT;
|
2008-05-22 20:31:40 +07:00
|
|
|
}
|
|
|
|
/* clear write bits if ATTR_READONLY is set */
|
|
|
|
if (attr & ATTR_READONLY)
|
|
|
|
inode->i_mode &= ~S_IWUGO;
|
|
|
|
|
|
|
|
/* set inode type */
|
|
|
|
if ((attr & ATTR_SYSTEM) &&
|
|
|
|
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
|
|
|
|
/* no need to fix endianness on 0 */
|
|
|
|
if (pfindData->EndOfFile == 0)
|
|
|
|
inode->i_mode |= S_IFIFO;
|
|
|
|
else if (decode_sfu_inode(inode,
|
|
|
|
le64_to_cpu(pfindData->EndOfFile),
|
|
|
|
full_path, cifs_sb, xid))
|
|
|
|
cFYI(1, ("unknown SFU file type\n"));
|
2008-05-21 04:52:32 +07:00
|
|
|
} else {
|
2008-05-22 20:31:40 +07:00
|
|
|
if (attr & ATTR_DIRECTORY)
|
|
|
|
inode->i_mode |= S_IFDIR;
|
|
|
|
else
|
|
|
|
inode->i_mode |= S_IFREG;
|
2008-05-21 04:52:32 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (is_size_safe_to_change(cifsInfo,
|
|
|
|
le64_to_cpu(pfindData->EndOfFile))) {
|
|
|
|
/* can not safely shrink the file size here if the
|
|
|
|
client is writing to it due to potential races */
|
|
|
|
i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
|
|
|
|
|
|
|
|
/* 512 bytes (2**9) is the fake blocksize that must be
|
|
|
|
used for this calculation */
|
|
|
|
inode->i_blocks = (512 - 1 + le64_to_cpu(
|
|
|
|
pfindData->AllocationSize)) >> 9;
|
|
|
|
}
|
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-21 04:52:32 +07:00
|
|
|
/* BB fill in uid and gid here? with help from winbind?
|
|
|
|
or retrieve from NTFS stream extended attribute */
|
2007-10-20 04:57:39 +07:00
|
|
|
#ifdef CONFIG_CIFS_EXPERIMENTAL
|
2008-05-21 04:52:32 +07:00
|
|
|
/* fill in 0777 bits from ACL */
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
|
|
|
|
cFYI(1, ("Getting mode bits from ACL"));
|
|
|
|
acl_to_uid_mode(inode, full_path, pfid);
|
|
|
|
}
|
2007-10-20 04:57:39 +07:00
|
|
|
#endif
|
2008-05-21 04:52:32 +07:00
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
|
|
|
|
/* fill in remaining high mode bits e.g. SUID, VTX */
|
|
|
|
get_sfu_mode(inode, full_path, cifs_sb, xid);
|
|
|
|
} else if (atomic_read(&cifsInfo->inUse) == 0) {
|
|
|
|
inode->i_uid = cifs_sb->mnt_uid;
|
|
|
|
inode->i_gid = cifs_sb->mnt_gid;
|
|
|
|
/* set so we do not keep refreshing these fields with
|
|
|
|
bad data after user has changed them in memory */
|
|
|
|
atomic_set(&cifsInfo->inUse, 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-05-21 04:52:32 +07:00
|
|
|
|
|
|
|
cifs_set_ops(inode, is_dfs_referral);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2008-03-09 10:44:18 +07:00
|
|
|
cgii_exit:
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(buf);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-09-29 05:28:55 +07:00
|
|
|
static const struct inode_operations cifs_ipc_inode_ops = {
|
|
|
|
.lookup = cifs_lookup,
|
|
|
|
};
|
|
|
|
|
2009-02-10 18:10:26 +07:00
|
|
|
char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
|
2008-12-06 02:14:12 +07:00
|
|
|
{
|
|
|
|
int pplen = cifs_sb->prepathlen;
|
|
|
|
int dfsplen;
|
|
|
|
char *full_path = NULL;
|
|
|
|
|
|
|
|
/* if no prefix path, simply set path to the root of share to "" */
|
|
|
|
if (pplen == 0) {
|
|
|
|
full_path = kmalloc(1, GFP_KERNEL);
|
|
|
|
if (full_path)
|
|
|
|
full_path[0] = 0;
|
|
|
|
return full_path;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
|
|
|
|
dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
|
|
|
|
else
|
|
|
|
dfsplen = 0;
|
|
|
|
|
|
|
|
full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
|
|
|
|
if (full_path == NULL)
|
|
|
|
return full_path;
|
|
|
|
|
|
|
|
if (dfsplen) {
|
|
|
|
strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
|
|
|
|
/* switch slash direction in prepath depending on whether
|
|
|
|
* windows or posix style path names
|
|
|
|
*/
|
|
|
|
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->prepath, pplen);
|
|
|
|
full_path[dfsplen + pplen] = 0; /* add trailing null */
|
|
|
|
return full_path;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* gets root inode */
|
2008-02-07 15:15:33 +07:00
|
|
|
struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-02-07 15:15:33 +07:00
|
|
|
int xid;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cifs_sb_info *cifs_sb;
|
2008-02-07 15:15:33 +07:00
|
|
|
struct inode *inode;
|
|
|
|
long rc;
|
2008-12-06 02:14:12 +07:00
|
|
|
char *full_path;
|
2008-02-07 15:15:33 +07:00
|
|
|
|
|
|
|
inode = iget_locked(sb, ino);
|
|
|
|
if (!inode)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
if (!(inode->i_state & I_NEW))
|
|
|
|
return inode;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(inode->i_sb);
|
2009-02-10 18:10:26 +07:00
|
|
|
full_path = cifs_build_path_to_root(cifs_sb);
|
2008-12-06 02:14:12 +07:00
|
|
|
if (full_path == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2007-07-19 06:21:09 +07:00
|
|
|
|
2008-12-06 02:14:12 +07:00
|
|
|
xid = GetXid();
|
2007-07-19 06:21:09 +07:00
|
|
|
if (cifs_sb->tcon->unix_ext)
|
2008-12-06 02:14:12 +07:00
|
|
|
rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
|
|
|
|
xid);
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2008-12-06 02:14:12 +07:00
|
|
|
rc = cifs_get_inode_info(&inode, full_path, NULL, inode->i_sb,
|
|
|
|
xid, NULL);
|
2007-09-29 05:28:55 +07:00
|
|
|
if (rc && cifs_sb->tcon->ipc) {
|
|
|
|
cFYI(1, ("ipc connection - fake read inode"));
|
|
|
|
inode->i_mode |= S_IFDIR;
|
|
|
|
inode->i_nlink = 2;
|
|
|
|
inode->i_op = &cifs_ipc_inode_ops;
|
|
|
|
inode->i_fop = &simple_dir_operations;
|
|
|
|
inode->i_uid = cifs_sb->mnt_uid;
|
|
|
|
inode->i_gid = cifs_sb->mnt_gid;
|
2008-08-12 21:14:40 +07:00
|
|
|
} else if (rc) {
|
2008-12-06 02:14:12 +07:00
|
|
|
kfree(full_path);
|
2008-02-07 15:15:33 +07:00
|
|
|
_FreeXid(xid);
|
|
|
|
iget_failed(inode);
|
|
|
|
return ERR_PTR(rc);
|
2007-09-29 05:28:55 +07:00
|
|
|
}
|
|
|
|
|
2008-02-07 15:15:33 +07:00
|
|
|
unlock_new_inode(inode);
|
|
|
|
|
2008-12-06 02:14:12 +07:00
|
|
|
kfree(full_path);
|
2008-02-07 15:15:33 +07:00
|
|
|
/* can not call macro FreeXid here since in a void func
|
|
|
|
* TODO: This is no longer true
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
_FreeXid(xid);
|
2008-02-07 15:15:33 +07:00
|
|
|
return inode;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-09-17 06:50:58 +07:00
|
|
|
static int
|
|
|
|
cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
|
|
|
|
char *full_path, __u32 dosattr)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
int oplock = 0;
|
|
|
|
__u16 netfid;
|
|
|
|
__u32 netpid;
|
|
|
|
bool set_time = false;
|
|
|
|
struct cifsFileInfo *open_file;
|
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
|
|
|
FILE_BASIC_INFO info_buf;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_ATIME) {
|
|
|
|
set_time = true;
|
|
|
|
info_buf.LastAccessTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
|
|
|
|
} else
|
|
|
|
info_buf.LastAccessTime = 0;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_MTIME) {
|
|
|
|
set_time = true;
|
|
|
|
info_buf.LastWriteTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
|
|
|
|
} else
|
|
|
|
info_buf.LastWriteTime = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Samba throws this field away, but windows may actually use it.
|
|
|
|
* Do not set ctime unless other time stamps are changed explicitly
|
|
|
|
* (i.e. by utimes()) since we would then have a mix of client and
|
|
|
|
* server times.
|
|
|
|
*/
|
|
|
|
if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
|
|
|
|
cFYI(1, ("CIFS - CTIME changed"));
|
|
|
|
info_buf.ChangeTime =
|
|
|
|
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
|
|
|
|
} else
|
|
|
|
info_buf.ChangeTime = 0;
|
|
|
|
|
|
|
|
info_buf.CreationTime = 0; /* don't change */
|
|
|
|
info_buf.Attributes = cpu_to_le32(dosattr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the file is already open for write, just use that fileid
|
|
|
|
*/
|
|
|
|
open_file = find_writable_file(cifsInode);
|
|
|
|
if (open_file) {
|
|
|
|
netfid = open_file->netfid;
|
|
|
|
netpid = open_file->pid;
|
|
|
|
goto set_via_filehandle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NT4 apparently returns success on this call, but it doesn't
|
|
|
|
* really work.
|
|
|
|
*/
|
|
|
|
if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
|
|
|
|
rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
|
|
|
|
&info_buf, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-10-07 04:54:41 +07:00
|
|
|
if (rc == 0) {
|
|
|
|
cifsInode->cifsAttrs = dosattr;
|
|
|
|
goto out;
|
|
|
|
} else if (rc != -EOPNOTSUPP && rc != -EINVAL)
|
2008-09-17 06:50:58 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cFYI(1, ("calling SetFileInfo since SetPathInfo for "
|
|
|
|
"times not supported by this server"));
|
|
|
|
rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
|
|
|
|
SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
|
|
|
|
CREATE_NOT_DIR, &netfid, &oplock,
|
|
|
|
NULL, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
|
|
|
if (rc != 0) {
|
|
|
|
if (rc == -EIO)
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
netpid = current->tgid;
|
|
|
|
|
|
|
|
set_via_filehandle:
|
|
|
|
rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
|
2008-09-25 02:22:52 +07:00
|
|
|
if (!rc)
|
|
|
|
cifsInode->cifsAttrs = dosattr;
|
|
|
|
|
2008-09-17 06:50:58 +07:00
|
|
|
if (open_file == NULL)
|
|
|
|
CIFSSMBClose(xid, pTcon, netfid);
|
|
|
|
else
|
|
|
|
atomic_dec(&open_file->wrtPending);
|
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-09-23 22:48:35 +07:00
|
|
|
/*
|
|
|
|
* open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
|
|
|
|
* and rename it to a random name that hopefully won't conflict with
|
|
|
|
* anything else.
|
|
|
|
*/
|
|
|
|
static int
|
2008-10-20 07:44:19 +07:00
|
|
|
cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
|
2008-09-23 22:48:35 +07:00
|
|
|
{
|
|
|
|
int oplock = 0;
|
|
|
|
int rc;
|
|
|
|
__u16 netfid;
|
2008-10-20 07:44:19 +07:00
|
|
|
struct inode *inode = dentry->d_inode;
|
2008-09-23 22:48:35 +07:00
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsTconInfo *tcon = cifs_sb->tcon;
|
2008-10-20 07:44:19 +07:00
|
|
|
__u32 dosattr, origattr;
|
|
|
|
FILE_BASIC_INFO *info_buf = NULL;
|
2008-09-23 22:48:35 +07:00
|
|
|
|
|
|
|
rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
|
2008-10-17 06:27:12 +07:00
|
|
|
DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
|
2008-09-23 22:48:35 +07:00
|
|
|
&netfid, &oplock, NULL, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
if (rc != 0)
|
|
|
|
goto out;
|
|
|
|
|
2008-10-20 07:44:19 +07:00
|
|
|
origattr = cifsInode->cifsAttrs;
|
|
|
|
if (origattr == 0)
|
|
|
|
origattr |= ATTR_NORMAL;
|
|
|
|
|
|
|
|
dosattr = origattr & ~ATTR_READONLY;
|
2008-09-23 22:48:35 +07:00
|
|
|
if (dosattr == 0)
|
|
|
|
dosattr |= ATTR_NORMAL;
|
|
|
|
dosattr |= ATTR_HIDDEN;
|
|
|
|
|
2008-10-20 07:44:19 +07:00
|
|
|
/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
|
|
|
|
if (dosattr != origattr) {
|
|
|
|
info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
|
|
|
|
if (info_buf == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out_close;
|
|
|
|
}
|
|
|
|
info_buf->Attributes = cpu_to_le32(dosattr);
|
|
|
|
rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
|
|
|
|
current->tgid);
|
|
|
|
/* although we would like to mark the file hidden
|
|
|
|
if that fails we will still try to rename it */
|
2008-10-21 01:24:42 +07:00
|
|
|
if (rc != 0)
|
2008-10-20 07:44:19 +07:00
|
|
|
cifsInode->cifsAttrs = dosattr;
|
|
|
|
else
|
|
|
|
dosattr = origattr; /* since not able to change them */
|
2008-09-23 22:48:35 +07:00
|
|
|
}
|
|
|
|
|
2008-10-17 06:27:12 +07:00
|
|
|
/* rename the file */
|
|
|
|
rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
|
2008-09-23 22:48:35 +07:00
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-10-20 07:44:19 +07:00
|
|
|
if (rc != 0) {
|
|
|
|
rc = -ETXTBSY;
|
|
|
|
goto undo_setattr;
|
|
|
|
}
|
2008-09-23 22:48:35 +07:00
|
|
|
|
2008-10-20 07:44:19 +07:00
|
|
|
/* try to set DELETE_ON_CLOSE */
|
|
|
|
if (!cifsInode->delete_pending) {
|
|
|
|
rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
|
|
|
|
current->tgid);
|
|
|
|
/*
|
|
|
|
* some samba versions return -ENOENT when we try to set the
|
|
|
|
* file disposition here. Likely a samba bug, but work around
|
|
|
|
* it for now. This means that some cifsXXX files may hang
|
|
|
|
* around after they shouldn't.
|
|
|
|
*
|
|
|
|
* BB: remove this hack after more servers have the fix
|
|
|
|
*/
|
|
|
|
if (rc == -ENOENT)
|
|
|
|
rc = 0;
|
|
|
|
else if (rc != 0) {
|
|
|
|
rc = -ETXTBSY;
|
|
|
|
goto undo_rename;
|
|
|
|
}
|
|
|
|
cifsInode->delete_pending = true;
|
|
|
|
}
|
2008-09-24 22:32:59 +07:00
|
|
|
|
2008-09-23 22:48:35 +07:00
|
|
|
out_close:
|
|
|
|
CIFSSMBClose(xid, tcon, netfid);
|
|
|
|
out:
|
2008-10-20 07:44:19 +07:00
|
|
|
kfree(info_buf);
|
2008-09-23 22:48:35 +07:00
|
|
|
return rc;
|
2008-10-20 07:44:19 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* reset everything back to the original state. Don't bother
|
|
|
|
* dealing with errors here since we can't do anything about
|
|
|
|
* them anyway.
|
|
|
|
*/
|
|
|
|
undo_rename:
|
|
|
|
CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
|
|
|
|
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
undo_setattr:
|
|
|
|
if (dosattr != origattr) {
|
|
|
|
info_buf->Attributes = cpu_to_le32(origattr);
|
|
|
|
if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
|
|
|
|
current->tgid))
|
|
|
|
cifsInode->cifsAttrs = origattr;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out_close;
|
2008-09-23 22:48:35 +07:00
|
|
|
}
|
|
|
|
|
2008-09-17 01:05:16 +07:00
|
|
|
int cifs_unlink(struct inode *dir, struct dentry *dentry)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
int xid;
|
|
|
|
char *full_path = NULL;
|
2008-09-17 01:05:16 +07:00
|
|
|
struct inode *inode = dentry->d_inode;
|
2008-10-08 01:42:52 +07:00
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
2008-09-17 01:05:16 +07:00
|
|
|
struct super_block *sb = dir->i_sb;
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
|
|
|
|
struct cifsTconInfo *tcon = cifs_sb->tcon;
|
2008-10-08 01:42:52 +07:00
|
|
|
struct iattr *attrs = NULL;
|
|
|
|
__u32 dosattr = 0, origattr = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-09-17 01:05:16 +07:00
|
|
|
cFYI(1, ("cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
2008-09-17 01:05:16 +07:00
|
|
|
/* Unlink can be called from rename so we can not take the
|
|
|
|
* sb->s_vfs_rename_mutex here */
|
|
|
|
full_path = build_path_from_dentry(dentry);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (full_path == NULL) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2007-07-15 08:48:57 +07:00
|
|
|
|
2008-09-17 01:05:16 +07:00
|
|
|
if ((tcon->ses->capabilities & CAP_UNIX) &&
|
2007-07-15 08:48:57 +07:00
|
|
|
(CIFS_UNIX_POSIX_PATH_OPS_CAP &
|
2008-09-17 01:05:16 +07:00
|
|
|
le64_to_cpu(tcon->fsUnixInfo.Capability))) {
|
|
|
|
rc = CIFSPOSIXDelFile(xid, tcon, full_path,
|
2007-07-15 08:48:57 +07:00
|
|
|
SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
|
2005-04-29 12:41:06 +07:00
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-07-15 08:48:57 +07:00
|
|
|
cFYI(1, ("posix del rc %d", rc));
|
|
|
|
if ((rc == 0) || (rc == -ENOENT))
|
|
|
|
goto psx_del_no_retry;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-10-08 01:42:52 +07:00
|
|
|
retry_std_delete:
|
2008-09-17 01:05:16 +07:00
|
|
|
rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
|
2007-07-15 08:48:57 +07:00
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-10-08 01:42:52 +07:00
|
|
|
|
2007-07-15 08:48:57 +07:00
|
|
|
psx_del_no_retry:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!rc) {
|
2008-09-17 01:05:16 +07:00
|
|
|
if (inode)
|
|
|
|
drop_nlink(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (rc == -ENOENT) {
|
2008-09-17 01:05:16 +07:00
|
|
|
d_drop(dentry);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (rc == -ETXTBSY) {
|
2008-10-20 07:44:19 +07:00
|
|
|
rc = cifs_rename_pending_delete(full_path, dentry, xid);
|
2008-09-23 22:48:35 +07:00
|
|
|
if (rc == 0)
|
|
|
|
drop_nlink(inode);
|
2008-10-08 01:42:52 +07:00
|
|
|
} else if (rc == -EACCES && dosattr == 0) {
|
2008-09-17 06:50:58 +07:00
|
|
|
attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
|
|
|
|
if (attrs == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out_reval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-09-17 06:50:58 +07:00
|
|
|
|
|
|
|
/* try to reset dos attributes */
|
2008-10-08 01:42:52 +07:00
|
|
|
origattr = cifsInode->cifsAttrs;
|
|
|
|
if (origattr == 0)
|
|
|
|
origattr |= ATTR_NORMAL;
|
|
|
|
dosattr = origattr & ~ATTR_READONLY;
|
2008-09-17 06:50:58 +07:00
|
|
|
if (dosattr == 0)
|
|
|
|
dosattr |= ATTR_NORMAL;
|
|
|
|
dosattr |= ATTR_HIDDEN;
|
|
|
|
|
|
|
|
rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
|
|
|
|
if (rc != 0)
|
|
|
|
goto out_reval;
|
2008-10-08 01:42:52 +07:00
|
|
|
|
|
|
|
goto retry_std_delete;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-10-08 01:42:52 +07:00
|
|
|
|
|
|
|
/* undo the setattr if we errored out and it's needed */
|
|
|
|
if (rc != 0 && dosattr != 0)
|
|
|
|
cifs_set_file_info(inode, attrs, xid, full_path, origattr);
|
|
|
|
|
2008-09-17 06:50:58 +07:00
|
|
|
out_reval:
|
2007-05-01 03:13:06 +07:00
|
|
|
if (inode) {
|
2006-04-01 05:43:50 +07:00
|
|
|
cifsInode = CIFS_I(inode);
|
2008-09-17 01:05:16 +07:00
|
|
|
cifsInode->time = 0; /* will force revalidate to get info
|
|
|
|
when needed */
|
|
|
|
inode->i_ctime = current_fs_time(sb);
|
2006-04-01 05:43:50 +07:00
|
|
|
}
|
2008-09-17 01:05:16 +07:00
|
|
|
dir->i_ctime = dir->i_mtime = current_fs_time(sb);
|
|
|
|
cifsInode = CIFS_I(dir);
|
2008-10-08 01:42:52 +07:00
|
|
|
CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
kfree(full_path);
|
2008-10-08 01:42:52 +07:00
|
|
|
kfree(attrs);
|
2005-04-17 05:20:36 +07:00
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-04-24 05:07:35 +07:00
|
|
|
static void posix_fill_in_inode(struct inode *tmp_inode,
|
2008-02-26 10:44:02 +07:00
|
|
|
FILE_UNIX_BASIC_INFO *pData, int isNewInode)
|
2007-04-24 05:07:35 +07:00
|
|
|
{
|
2008-02-26 03:25:21 +07:00
|
|
|
struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
|
2007-04-24 05:07:35 +07:00
|
|
|
loff_t local_size;
|
|
|
|
struct timespec local_mtime;
|
|
|
|
|
|
|
|
cifsInfo->time = jiffies;
|
|
|
|
atomic_inc(&cifsInfo->inUse);
|
|
|
|
|
|
|
|
/* save mtime and size */
|
|
|
|
local_mtime = tmp_inode->i_mtime;
|
|
|
|
local_size = tmp_inode->i_size;
|
|
|
|
|
2008-02-26 03:25:21 +07:00
|
|
|
cifs_unix_info_to_inode(tmp_inode, pData, 1);
|
2008-03-09 10:44:18 +07:00
|
|
|
cifs_set_ops(tmp_inode, false);
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2008-02-26 03:25:21 +07:00
|
|
|
if (!S_ISREG(tmp_inode->i_mode))
|
|
|
|
return;
|
2007-04-24 05:07:35 +07:00
|
|
|
|
2008-02-26 03:25:21 +07:00
|
|
|
/*
|
|
|
|
* No sense invalidating pages for new inode
|
|
|
|
* since we we have not started caching
|
|
|
|
* readahead file data yet.
|
|
|
|
*/
|
|
|
|
if (isNewInode)
|
|
|
|
return;
|
2007-04-24 05:07:35 +07:00
|
|
|
|
2008-02-26 03:25:21 +07:00
|
|
|
if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
|
|
|
|
(local_size == tmp_inode->i_size)) {
|
|
|
|
cFYI(1, ("inode exists but unchanged"));
|
2007-04-24 05:07:35 +07:00
|
|
|
} else {
|
2008-02-26 03:25:21 +07:00
|
|
|
/* file may have changed on server */
|
|
|
|
cFYI(1, ("invalidate inode, readdir detected change"));
|
|
|
|
invalidate_remote_inode(tmp_inode);
|
2007-07-10 08:16:18 +07:00
|
|
|
}
|
2007-04-24 05:07:35 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
|
|
|
|
{
|
2008-10-07 04:54:41 +07:00
|
|
|
int rc = 0, tmprc;
|
2005-04-17 05:20:36 +07:00
|
|
|
int xid;
|
|
|
|
struct cifs_sb_info *cifs_sb;
|
|
|
|
struct cifsTconInfo *pTcon;
|
|
|
|
char *full_path = NULL;
|
|
|
|
struct inode *newinode = NULL;
|
|
|
|
|
2005-11-30 11:20:10 +07:00
|
|
|
cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
pTcon = cifs_sb->tcon;
|
|
|
|
|
2005-08-31 01:32:14 +07:00
|
|
|
full_path = build_path_from_dentry(direntry);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (full_path == NULL) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
if ((pTcon->ses->capabilities & CAP_UNIX) &&
|
|
|
|
(CIFS_UNIX_POSIX_PATH_OPS_CAP &
|
2007-04-24 05:07:35 +07:00
|
|
|
le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
|
|
|
|
u32 oplock = 0;
|
2008-01-09 06:18:22 +07:00
|
|
|
FILE_UNIX_BASIC_INFO *pInfo =
|
2007-04-24 05:07:35 +07:00
|
|
|
kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
|
2007-07-10 08:16:18 +07:00
|
|
|
if (pInfo == NULL) {
|
2007-04-24 05:07:35 +07:00
|
|
|
rc = -ENOMEM;
|
|
|
|
goto mkdir_out;
|
|
|
|
}
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2007-09-14 01:38:50 +07:00
|
|
|
mode &= ~current->fs->umask;
|
2007-04-24 05:07:35 +07:00
|
|
|
rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
|
|
|
|
mode, NULL /* netfid */, pInfo, &oplock,
|
2007-07-10 08:16:18 +07:00
|
|
|
full_path, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
2007-04-24 05:07:35 +07:00
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-09-17 09:04:21 +07:00
|
|
|
if (rc == -EOPNOTSUPP) {
|
|
|
|
kfree(pInfo);
|
|
|
|
goto mkdir_retry_old;
|
|
|
|
} else if (rc) {
|
2007-04-24 05:07:35 +07:00
|
|
|
cFYI(1, ("posix mkdir returned 0x%x", rc));
|
|
|
|
d_drop(direntry);
|
|
|
|
} else {
|
2007-10-15 00:58:43 +07:00
|
|
|
if (pInfo->Type == cpu_to_le32(-1)) {
|
|
|
|
/* no return info, go query for it */
|
2007-09-17 06:12:47 +07:00
|
|
|
kfree(pInfo);
|
2007-07-10 08:16:18 +07:00
|
|
|
goto mkdir_get_info;
|
2007-09-17 06:12:47 +07:00
|
|
|
}
|
2007-07-10 08:16:18 +07:00
|
|
|
/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
|
|
|
|
to set uid/gid */
|
2007-04-24 05:07:35 +07:00
|
|
|
inc_nlink(inode);
|
|
|
|
if (pTcon->nocase)
|
|
|
|
direntry->d_op = &cifs_ci_dentry_ops;
|
|
|
|
else
|
|
|
|
direntry->d_op = &cifs_dentry_ops;
|
2007-04-25 18:46:06 +07:00
|
|
|
|
2009-02-11 20:08:26 +07:00
|
|
|
newinode = cifs_new_inode(inode->i_sb,
|
|
|
|
&pInfo->UniqueId);
|
2007-09-17 06:12:47 +07:00
|
|
|
if (newinode == NULL) {
|
|
|
|
kfree(pInfo);
|
2007-04-25 18:46:06 +07:00
|
|
|
goto mkdir_get_info;
|
2007-09-17 06:12:47 +07:00
|
|
|
}
|
2008-10-07 04:54:41 +07:00
|
|
|
|
2007-04-25 18:46:06 +07:00
|
|
|
newinode->i_nlink = 2;
|
2007-04-24 05:07:35 +07:00
|
|
|
d_instantiate(direntry, newinode);
|
2007-04-25 18:46:06 +07:00
|
|
|
|
|
|
|
/* we already checked in POSIXCreate whether
|
|
|
|
frame was long enough */
|
|
|
|
posix_fill_in_inode(direntry->d_inode,
|
2008-02-26 10:44:02 +07:00
|
|
|
pInfo, 1 /* NewInode */);
|
2007-04-25 18:46:06 +07:00
|
|
|
#ifdef CONFIG_CIFS_DEBUG2
|
2007-07-10 08:16:18 +07:00
|
|
|
cFYI(1, ("instantiated dentry %p %s to inode %p",
|
2007-04-25 18:46:06 +07:00
|
|
|
direntry, direntry->d_name.name, newinode));
|
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
if (newinode->i_nlink != 2)
|
|
|
|
cFYI(1, ("unexpected number of links %d",
|
2007-04-25 18:46:06 +07:00
|
|
|
newinode->i_nlink));
|
|
|
|
#endif
|
2007-04-24 05:07:35 +07:00
|
|
|
}
|
|
|
|
kfree(pInfo);
|
|
|
|
goto mkdir_out;
|
2007-07-10 08:16:18 +07:00
|
|
|
}
|
2007-09-17 09:04:21 +07:00
|
|
|
mkdir_retry_old:
|
2005-04-17 05:20:36 +07:00
|
|
|
/* BB add setting the equivalent of mode via CreateX w/ACLs */
|
2005-04-29 12:41:06 +07:00
|
|
|
rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc) {
|
2006-06-01 01:05:34 +07:00
|
|
|
cFYI(1, ("cifs_mkdir returned 0x%x", rc));
|
2005-04-17 05:20:36 +07:00
|
|
|
d_drop(direntry);
|
|
|
|
} else {
|
2007-07-10 08:16:18 +07:00
|
|
|
mkdir_get_info:
|
2006-10-01 13:29:04 +07:00
|
|
|
inc_nlink(inode);
|
2007-07-19 06:21:09 +07:00
|
|
|
if (pTcon->unix_ext)
|
2005-04-17 05:20:36 +07:00
|
|
|
rc = cifs_get_inode_info_unix(&newinode, full_path,
|
2007-07-10 08:16:18 +07:00
|
|
|
inode->i_sb, xid);
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
|
|
|
rc = cifs_get_inode_info(&newinode, full_path, NULL,
|
2008-03-15 05:37:16 +07:00
|
|
|
inode->i_sb, xid, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-23 10:09:43 +07:00
|
|
|
if (pTcon->nocase)
|
|
|
|
direntry->d_op = &cifs_ci_dentry_ops;
|
|
|
|
else
|
|
|
|
direntry->d_op = &cifs_dentry_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
d_instantiate(direntry, newinode);
|
2007-04-24 05:07:35 +07:00
|
|
|
/* setting nlink not necessary except in cases where we
|
2007-07-10 08:16:18 +07:00
|
|
|
* failed to get it from the server or was set bogus */
|
2007-04-24 05:07:35 +07:00
|
|
|
if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
|
2007-07-10 08:16:18 +07:00
|
|
|
direntry->d_inode->i_nlink = 2;
|
2008-08-06 11:39:02 +07:00
|
|
|
|
2008-05-10 05:28:02 +07:00
|
|
|
mode &= ~current->fs->umask;
|
2008-08-06 11:39:02 +07:00
|
|
|
/* must turn on setgid bit if parent dir has it */
|
|
|
|
if (inode->i_mode & S_ISGID)
|
|
|
|
mode |= S_ISGID;
|
|
|
|
|
2007-07-19 06:21:09 +07:00
|
|
|
if (pTcon->unix_ext) {
|
2008-08-02 18:26:12 +07:00
|
|
|
struct cifs_unix_set_info_args args = {
|
|
|
|
.mode = mode,
|
|
|
|
.ctime = NO_CHANGE_64,
|
|
|
|
.atime = NO_CHANGE_64,
|
|
|
|
.mtime = NO_CHANGE_64,
|
|
|
|
.device = 0,
|
|
|
|
};
|
2005-06-03 05:12:36 +07:00
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
|
2008-11-14 06:38:47 +07:00
|
|
|
args.uid = (__u64)current_fsuid();
|
2008-08-06 11:39:02 +07:00
|
|
|
if (inode->i_mode & S_ISGID)
|
|
|
|
args.gid = (__u64)inode->i_gid;
|
|
|
|
else
|
2008-11-14 06:38:47 +07:00
|
|
|
args.gid = (__u64)current_fsgid();
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2008-08-02 18:26:12 +07:00
|
|
|
args.uid = NO_CHANGE_64;
|
|
|
|
args.gid = NO_CHANGE_64;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-08-02 18:26:12 +07:00
|
|
|
CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
|
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2007-06-08 21:55:14 +07:00
|
|
|
} else {
|
2008-05-10 05:28:02 +07:00
|
|
|
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
|
|
|
|
(mode & S_IWUGO) == 0) {
|
|
|
|
FILE_BASIC_INFO pInfo;
|
2008-10-07 04:54:41 +07:00
|
|
|
struct cifsInodeInfo *cifsInode;
|
|
|
|
u32 dosattrs;
|
|
|
|
|
2008-05-10 05:28:02 +07:00
|
|
|
memset(&pInfo, 0, sizeof(pInfo));
|
2008-10-07 04:54:41 +07:00
|
|
|
cifsInode = CIFS_I(newinode);
|
|
|
|
dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
|
|
|
|
pInfo.Attributes = cpu_to_le32(dosattrs);
|
|
|
|
tmprc = CIFSSMBSetPathInfo(xid, pTcon,
|
|
|
|
full_path, &pInfo,
|
|
|
|
cifs_sb->local_nls,
|
2008-05-10 05:28:02 +07:00
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-10-07 04:54:41 +07:00
|
|
|
if (tmprc == 0)
|
|
|
|
cifsInode->cifsAttrs = dosattrs;
|
2008-05-10 05:28:02 +07:00
|
|
|
}
|
2007-07-10 08:16:18 +07:00
|
|
|
if (direntry->d_inode) {
|
when creating new inodes, use file_mode/dir_mode exclusively on mount without unix extensions
When CIFS creates a new inode on a mount without unix extensions, it
temporarily assigns the mode that was passed to it in the create/mkdir
call. Eventually, when the inode is revalidated, it changes to have the
file_mode or dir_mode for the mount. This is confusing to users who
expect that the mode shouldn't change this way. It's also problematic
since only the mode is treated this way, not the uid or gid. Suppose you
have a CIFS mount that's mounted with:
uid=0,gid=0,file_mode=0666,dir_mode=0777
...if an unprivileged user comes along and does this on the mount:
mkdir -m 0700 foo
touch foo/bar
...there is a period of time where the touch will fail, since the dir
will initially be owned by root and have mode 0700. If the user waits
long enough, then "foo" will be revalidated and will get the correct
dir_mode permissions.
This patch changes cifs_mkdir and cifs_create to not overwrite the
mode found by the initial cifs_get_inode_info call after the inode is
created on the server. Legacy behavior can be reenabled with the
new "dynperm" mount option.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2008-05-22 20:33:34 +07:00
|
|
|
if (cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_DYNPERM)
|
|
|
|
direntry->d_inode->i_mode =
|
|
|
|
(mode | S_IFDIR);
|
2008-05-24 01:22:46 +07:00
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
if (cifs_sb->mnt_cifs_flags &
|
2005-11-30 11:20:10 +07:00
|
|
|
CIFS_MOUNT_SET_UID) {
|
2007-07-10 08:16:18 +07:00
|
|
|
direntry->d_inode->i_uid =
|
2008-11-14 06:38:47 +07:00
|
|
|
current_fsuid();
|
2008-08-06 11:39:02 +07:00
|
|
|
if (inode->i_mode & S_ISGID)
|
|
|
|
direntry->d_inode->i_gid =
|
|
|
|
inode->i_gid;
|
|
|
|
else
|
|
|
|
direntry->d_inode->i_gid =
|
2008-11-14 06:38:47 +07:00
|
|
|
current_fsgid();
|
2005-11-30 11:20:10 +07:00
|
|
|
}
|
|
|
|
}
|
2005-11-30 12:22:19 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-07-10 08:16:18 +07:00
|
|
|
mkdir_out:
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cifs_rmdir(struct inode *inode, struct dentry *direntry)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
int xid;
|
|
|
|
struct cifs_sb_info *cifs_sb;
|
|
|
|
struct cifsTconInfo *pTcon;
|
|
|
|
char *full_path = NULL;
|
|
|
|
struct cifsInodeInfo *cifsInode;
|
|
|
|
|
2006-06-01 01:05:34 +07:00
|
|
|
cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
pTcon = cifs_sb->tcon;
|
|
|
|
|
2005-08-31 01:32:14 +07:00
|
|
|
full_path = build_path_from_dentry(direntry);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (full_path == NULL) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-04-29 12:41:06 +07:00
|
|
|
rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!rc) {
|
2006-10-01 13:29:03 +07:00
|
|
|
drop_nlink(inode);
|
2007-02-26 23:46:11 +07:00
|
|
|
spin_lock(&direntry->d_inode->i_lock);
|
2007-07-10 08:16:18 +07:00
|
|
|
i_size_write(direntry->d_inode, 0);
|
2006-10-01 13:29:06 +07:00
|
|
|
clear_nlink(direntry->d_inode);
|
2007-02-26 23:46:11 +07:00
|
|
|
spin_unlock(&direntry->d_inode->i_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
cifsInode = CIFS_I(direntry->d_inode);
|
|
|
|
cifsInode->time = 0; /* force revalidate to go get info when
|
|
|
|
needed */
|
2009-01-14 05:03:55 +07:00
|
|
|
|
|
|
|
cifsInode = CIFS_I(inode);
|
|
|
|
cifsInode->time = 0; /* force revalidate to get parent dir info
|
|
|
|
since cached search results now invalid */
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
|
|
|
|
current_fs_time(inode->i_sb);
|
|
|
|
|
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-09-24 01:23:33 +07:00
|
|
|
static int
|
|
|
|
cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
|
|
|
|
struct dentry *to_dentry, const char *toPath)
|
|
|
|
{
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
|
|
|
__u16 srcfid;
|
|
|
|
int oplock, rc;
|
|
|
|
|
|
|
|
/* try path-based rename first */
|
|
|
|
rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* don't bother with rename by filehandle unless file is busy and
|
|
|
|
* source Note that cross directory moves do not work with
|
|
|
|
* rename by filehandle to various Windows servers.
|
|
|
|
*/
|
|
|
|
if (rc == 0 || rc != -ETXTBSY)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* open the file to be renamed -- we need DELETE perms */
|
|
|
|
rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
|
|
|
|
CREATE_NOT_DIR, &srcfid, &oplock, NULL,
|
|
|
|
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
|
|
|
if (rc == 0) {
|
|
|
|
rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
|
|
|
|
(const char *) to_dentry->d_name.name,
|
|
|
|
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
|
|
|
CIFSSMBClose(xid, pTcon, srcfid);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-10-21 01:45:22 +07:00
|
|
|
int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
|
|
|
|
struct inode *target_dir, struct dentry *target_dentry)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-09-24 01:23:33 +07:00
|
|
|
char *fromName = NULL;
|
|
|
|
char *toName = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cifs_sb_info *cifs_sb_source;
|
|
|
|
struct cifs_sb_info *cifs_sb_target;
|
2008-10-21 01:45:22 +07:00
|
|
|
struct cifsTconInfo *tcon;
|
2008-09-24 01:23:33 +07:00
|
|
|
FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
|
|
|
|
FILE_UNIX_BASIC_INFO *info_buf_target;
|
2008-10-23 00:57:01 +07:00
|
|
|
int xid, rc, tmprc;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-10-21 01:45:22 +07:00
|
|
|
cifs_sb_target = CIFS_SB(target_dir->i_sb);
|
|
|
|
cifs_sb_source = CIFS_SB(source_dir->i_sb);
|
|
|
|
tcon = cifs_sb_source->tcon;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-09-24 01:23:33 +07:00
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* BB: this might be allowed if same server, but different share.
|
|
|
|
* Consider adding support for this
|
|
|
|
*/
|
2008-10-21 01:45:22 +07:00
|
|
|
if (tcon != cifs_sb_target->tcon) {
|
2008-09-24 01:23:33 +07:00
|
|
|
rc = -EXDEV;
|
|
|
|
goto cifs_rename_exit;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-09-24 01:23:33 +07:00
|
|
|
/*
|
|
|
|
* we already have the rename sem so we do not need to
|
|
|
|
* grab it again here to protect the path integrity
|
|
|
|
*/
|
2008-10-21 01:45:22 +07:00
|
|
|
fromName = build_path_from_dentry(source_dentry);
|
2008-09-24 01:23:33 +07:00
|
|
|
if (fromName == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cifs_rename_exit;
|
|
|
|
}
|
|
|
|
|
2008-10-21 01:45:22 +07:00
|
|
|
toName = build_path_from_dentry(target_dentry);
|
2008-09-24 01:23:33 +07:00
|
|
|
if (toName == NULL) {
|
2005-04-17 05:20:36 +07:00
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cifs_rename_exit;
|
|
|
|
}
|
|
|
|
|
2008-10-21 01:45:22 +07:00
|
|
|
rc = cifs_do_rename(xid, source_dentry, fromName,
|
|
|
|
target_dentry, toName);
|
2008-09-24 01:23:33 +07:00
|
|
|
|
2008-10-21 01:45:22 +07:00
|
|
|
if (rc == -EEXIST && tcon->unix_ext) {
|
|
|
|
/*
|
|
|
|
* Are src and dst hardlinks of same inode? We can
|
|
|
|
* only tell with unix extensions enabled
|
|
|
|
*/
|
|
|
|
info_buf_source =
|
|
|
|
kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (info_buf_source == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto cifs_rename_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
info_buf_target = info_buf_source + 1;
|
2008-10-23 00:57:01 +07:00
|
|
|
tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
|
2008-10-21 01:45:22 +07:00
|
|
|
info_buf_source,
|
|
|
|
cifs_sb_source->local_nls,
|
|
|
|
cifs_sb_source->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
2008-10-23 00:57:01 +07:00
|
|
|
if (tmprc != 0)
|
2008-10-21 01:45:22 +07:00
|
|
|
goto unlink_target;
|
2008-09-24 01:23:33 +07:00
|
|
|
|
2008-10-23 00:57:01 +07:00
|
|
|
tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
|
2008-10-21 01:45:22 +07:00
|
|
|
toName, info_buf_target,
|
|
|
|
cifs_sb_target->local_nls,
|
|
|
|
/* remap based on source sb */
|
|
|
|
cifs_sb_source->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
2008-10-23 00:57:01 +07:00
|
|
|
if (tmprc == 0 && (info_buf_source->UniqueId ==
|
2008-11-04 02:05:08 +07:00
|
|
|
info_buf_target->UniqueId)) {
|
2008-10-21 01:45:22 +07:00
|
|
|
/* same file, POSIX says that this is a noop */
|
2008-11-04 02:05:08 +07:00
|
|
|
rc = 0;
|
2008-10-21 01:45:22 +07:00
|
|
|
goto cifs_rename_exit;
|
2008-11-04 02:05:08 +07:00
|
|
|
}
|
2008-10-21 01:45:22 +07:00
|
|
|
} /* else ... BB we could add the same check for Windows by
|
2008-09-24 01:23:33 +07:00
|
|
|
checking the UniqueId via FILE_INTERNAL_INFO */
|
2008-10-21 01:45:22 +07:00
|
|
|
|
2008-09-24 01:23:33 +07:00
|
|
|
unlink_target:
|
2008-10-23 00:57:01 +07:00
|
|
|
if ((rc == -EACCES) || (rc == -EEXIST)) {
|
|
|
|
tmprc = cifs_unlink(target_dir, target_dentry);
|
2008-10-21 01:45:22 +07:00
|
|
|
if (tmprc)
|
|
|
|
goto cifs_rename_exit;
|
|
|
|
|
|
|
|
rc = cifs_do_rename(xid, source_dentry, fromName,
|
|
|
|
target_dentry, toName);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
cifs_rename_exit:
|
2008-09-24 01:23:33 +07:00
|
|
|
kfree(info_buf_source);
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(fromName);
|
|
|
|
kfree(toName);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cifs_revalidate(struct dentry *direntry)
|
|
|
|
{
|
|
|
|
int xid;
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
int rc = 0, wbrc = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
char *full_path;
|
|
|
|
struct cifs_sb_info *cifs_sb;
|
|
|
|
struct cifsInodeInfo *cifsInode;
|
|
|
|
loff_t local_size;
|
|
|
|
struct timespec local_mtime;
|
2008-04-29 07:06:05 +07:00
|
|
|
bool invalidate_inode = false;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (direntry->d_inode == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
cifsInode = CIFS_I(direntry->d_inode);
|
|
|
|
|
|
|
|
if (cifsInode == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
/* no sense revalidating inode info on file that no one can write */
|
|
|
|
if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
cifs_sb = CIFS_SB(direntry->d_sb);
|
|
|
|
|
|
|
|
/* can not safely grab the rename sem here if rename calls revalidate
|
|
|
|
since that would deadlock */
|
2005-08-31 01:32:14 +07:00
|
|
|
full_path = build_path_from_dentry(direntry);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (full_path == NULL) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
|
|
|
|
"jiffies %ld", full_path, direntry->d_inode,
|
|
|
|
direntry->d_inode->i_count.counter, direntry,
|
|
|
|
direntry->d_time, jiffies));
|
|
|
|
|
|
|
|
if (cifsInode->time == 0) {
|
|
|
|
/* was set to zero previously to force revalidate */
|
|
|
|
} else if (time_before(jiffies, cifsInode->time + HZ) &&
|
|
|
|
lookupCacheEnabled) {
|
|
|
|
if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
|
|
|
|
(direntry->d_inode->i_nlink == 1)) {
|
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
} else {
|
|
|
|
cFYI(1, ("Have to revalidate file due to hardlinks"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* save mtime and size */
|
|
|
|
local_mtime = direntry->d_inode->i_mtime;
|
|
|
|
local_size = direntry->d_inode->i_size;
|
|
|
|
|
2007-07-19 06:21:09 +07:00
|
|
|
if (cifs_sb->tcon->unix_ext) {
|
2005-04-17 05:20:36 +07:00
|
|
|
rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
|
2007-07-10 08:16:18 +07:00
|
|
|
direntry->d_sb, xid);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc) {
|
|
|
|
cFYI(1, ("error on getting revalidate info %d", rc));
|
|
|
|
/* if (rc != -ENOENT)
|
|
|
|
rc = 0; */ /* BB should we cache info on
|
|
|
|
certain errors? */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
|
2008-03-15 05:37:16 +07:00
|
|
|
direntry->d_sb, xid, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rc) {
|
|
|
|
cFYI(1, ("error on getting revalidate info %d", rc));
|
|
|
|
/* if (rc != -ENOENT)
|
|
|
|
rc = 0; */ /* BB should we cache info on
|
|
|
|
certain errors? */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* should we remap certain errors, access denied?, to zero */
|
|
|
|
|
|
|
|
/* if not oplocked, we invalidate inode pages if mtime or file size
|
|
|
|
had changed on server */
|
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
|
2005-04-17 05:20:36 +07:00
|
|
|
(local_size == direntry->d_inode->i_size)) {
|
|
|
|
cFYI(1, ("cifs_revalidate - inode unchanged"));
|
|
|
|
} else {
|
|
|
|
/* file may have changed on server */
|
|
|
|
if (cifsInode->clientCanCacheRead) {
|
|
|
|
/* no need to invalidate inode pages since we were the
|
|
|
|
only ones who could have modified the file and the
|
|
|
|
server copy is staler than ours */
|
|
|
|
} else {
|
2008-04-29 07:06:05 +07:00
|
|
|
invalidate_inode = true;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* can not grab this sem since kernel filesys locking documentation
|
2006-01-10 06:59:24 +07:00
|
|
|
indicates i_mutex may be taken by the kernel on lookup and rename
|
|
|
|
which could deadlock if we grab the i_mutex here as well */
|
|
|
|
/* mutex_lock(&direntry->d_inode->i_mutex);*/
|
2005-04-17 05:20:36 +07:00
|
|
|
/* need to write out dirty pages here */
|
|
|
|
if (direntry->d_inode->i_mapping) {
|
|
|
|
/* do we need to lock inode until after invalidate completes
|
|
|
|
below? */
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
|
|
|
|
if (wbrc)
|
|
|
|
CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
if (invalidate_inode) {
|
2005-11-28 23:16:13 +07:00
|
|
|
/* shrink_dcache not necessary now that cifs dentry ops
|
|
|
|
are exported for negative dentries */
|
2007-07-10 08:16:18 +07:00
|
|
|
/* if (S_ISDIR(direntry->d_inode->i_mode))
|
2005-11-28 23:16:13 +07:00
|
|
|
shrink_dcache_parent(direntry); */
|
|
|
|
if (S_ISREG(direntry->d_inode->i_mode)) {
|
2008-08-05 16:08:40 +07:00
|
|
|
if (direntry->d_inode->i_mapping) {
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
|
|
|
|
if (wbrc)
|
|
|
|
CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
|
2008-08-05 16:08:40 +07:00
|
|
|
}
|
2005-11-28 23:16:13 +07:00
|
|
|
/* may eventually have to do this for open files too */
|
|
|
|
if (list_empty(&(cifsInode->openFileList))) {
|
|
|
|
/* changed on server - flush read ahead pages */
|
|
|
|
cFYI(1, ("Invalidating read ahead data on "
|
|
|
|
"closed file"));
|
|
|
|
invalidate_remote_inode(direntry->d_inode);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2006-01-10 06:59:24 +07:00
|
|
|
/* mutex_unlock(&direntry->d_inode->i_mutex); */
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|
|
|
struct kstat *stat)
|
|
|
|
{
|
|
|
|
int err = cifs_revalidate(dentry);
|
2006-11-08 02:26:33 +07:00
|
|
|
if (!err) {
|
2005-04-17 05:20:36 +07:00
|
|
|
generic_fillattr(dentry->d_inode, stat);
|
2006-11-08 02:26:33 +07:00
|
|
|
stat->blksize = CIFS_MAX_MSGSIZE;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cifs_truncate_page(struct address_space *mapping, loff_t from)
|
|
|
|
{
|
|
|
|
pgoff_t index = from >> PAGE_CACHE_SHIFT;
|
|
|
|
unsigned offset = from & (PAGE_CACHE_SIZE - 1);
|
|
|
|
struct page *page;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
page = grab_cache_page(mapping, index);
|
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-02-05 13:28:29 +07:00
|
|
|
zero_user_segment(page, offset, PAGE_CACHE_SIZE);
|
2005-04-17 05:20:36 +07:00
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-07-10 08:16:18 +07:00
|
|
|
static int cifs_vmtruncate(struct inode *inode, loff_t offset)
|
2007-02-26 23:46:11 +07:00
|
|
|
{
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
unsigned long limit;
|
|
|
|
|
2007-02-27 03:06:29 +07:00
|
|
|
spin_lock(&inode->i_lock);
|
2007-02-26 23:46:11 +07:00
|
|
|
if (inode->i_size < offset)
|
|
|
|
goto do_expand;
|
|
|
|
/*
|
|
|
|
* truncation of in-use swapfiles is disallowed - it would cause
|
|
|
|
* subsequent swapout to scribble on the now-freed blocks.
|
|
|
|
*/
|
2007-02-27 03:06:29 +07:00
|
|
|
if (IS_SWAPFILE(inode)) {
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-02-26 23:46:11 +07:00
|
|
|
goto out_busy;
|
2007-02-27 03:06:29 +07:00
|
|
|
}
|
2007-02-26 23:46:11 +07:00
|
|
|
i_size_write(inode, offset);
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-08-23 05:12:07 +07:00
|
|
|
/*
|
|
|
|
* unmap_mapping_range is called twice, first simply for efficiency
|
|
|
|
* so that truncate_inode_pages does fewer single-page unmaps. However
|
|
|
|
* after this first call, and before truncate_inode_pages finishes,
|
|
|
|
* it is possible for private pages to be COWed, which remain after
|
|
|
|
* truncate_inode_pages finishes, hence the second unmap_mapping_range
|
|
|
|
* call must be made for correctness.
|
|
|
|
*/
|
2007-02-26 23:46:11 +07:00
|
|
|
unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
|
|
|
|
truncate_inode_pages(mapping, offset);
|
2007-08-23 05:12:07 +07:00
|
|
|
unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
|
2007-02-26 23:46:11 +07:00
|
|
|
goto out_truncate;
|
|
|
|
|
|
|
|
do_expand:
|
|
|
|
limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
|
2007-02-27 03:06:29 +07:00
|
|
|
if (limit != RLIM_INFINITY && offset > limit) {
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-02-26 23:46:11 +07:00
|
|
|
goto out_sig;
|
2007-02-27 03:06:29 +07:00
|
|
|
}
|
|
|
|
if (offset > inode->i_sb->s_maxbytes) {
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-02-26 23:46:11 +07:00
|
|
|
goto out_big;
|
2007-02-27 03:06:29 +07:00
|
|
|
}
|
2007-02-26 23:46:11 +07:00
|
|
|
i_size_write(inode, offset);
|
2007-02-27 03:06:29 +07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-02-26 23:46:11 +07:00
|
|
|
out_truncate:
|
2008-12-04 22:06:33 +07:00
|
|
|
if (inode->i_op->truncate)
|
2007-02-26 23:46:11 +07:00
|
|
|
inode->i_op->truncate(inode);
|
|
|
|
return 0;
|
|
|
|
out_sig:
|
|
|
|
send_sig(SIGXFSZ, current, 0);
|
|
|
|
out_big:
|
|
|
|
return -EFBIG;
|
|
|
|
out_busy:
|
|
|
|
return -ETXTBSY;
|
|
|
|
}
|
|
|
|
|
2008-07-24 04:28:12 +07:00
|
|
|
static int
|
|
|
|
cifs_set_file_size(struct inode *inode, struct iattr *attrs,
|
|
|
|
int xid, char *full_path)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct cifsFileInfo *open_file;
|
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To avoid spurious oplock breaks from server, in the case of
|
|
|
|
* inodes that we already have open, avoid doing path based
|
|
|
|
* setting of file size if we can do it by handle.
|
|
|
|
* This keeps our caching token (oplock) and avoids timeouts
|
|
|
|
* when the local oplock break takes longer to flush
|
|
|
|
* writebehind data than the SMB timeout for the SetPathInfo
|
|
|
|
* request would allow
|
|
|
|
*/
|
|
|
|
open_file = find_writable_file(cifsInode);
|
|
|
|
if (open_file) {
|
|
|
|
__u16 nfid = open_file->netfid;
|
|
|
|
__u32 npid = open_file->pid;
|
|
|
|
rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
|
|
|
|
npid, false);
|
|
|
|
atomic_dec(&open_file->wrtPending);
|
|
|
|
cFYI(1, ("SetFSize for attrs rc = %d", rc));
|
|
|
|
if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
|
|
|
|
unsigned int bytes_written;
|
|
|
|
rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
|
|
|
|
&bytes_written, NULL, NULL, 1);
|
|
|
|
cFYI(1, ("Wrt seteof rc %d", rc));
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
|
|
|
if (rc != 0) {
|
|
|
|
/* Set file size by pathname rather than by handle
|
|
|
|
either because no valid, writeable file handle for
|
|
|
|
it was found or because there was an error setting
|
|
|
|
it by handle */
|
|
|
|
rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
|
|
|
|
false, cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
|
|
|
|
if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
|
|
|
|
__u16 netfid;
|
|
|
|
int oplock = 0;
|
|
|
|
|
|
|
|
rc = SMBLegacyOpen(xid, pTcon, full_path,
|
|
|
|
FILE_OPEN, GENERIC_WRITE,
|
|
|
|
CREATE_NOT_DIR, &netfid, &oplock, NULL,
|
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
if (rc == 0) {
|
|
|
|
unsigned int bytes_written;
|
|
|
|
rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
|
|
|
|
attrs->ia_size,
|
|
|
|
&bytes_written, NULL,
|
|
|
|
NULL, 1);
|
|
|
|
cFYI(1, ("wrt seteof rc %d", rc));
|
|
|
|
CIFSSMBClose(xid, pTcon, netfid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc == 0) {
|
|
|
|
rc = cifs_vmtruncate(inode, attrs->ia_size);
|
|
|
|
cifs_truncate_page(inode->i_mapping, inode->i_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:26:12 +07:00
|
|
|
static int
|
|
|
|
cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
int xid;
|
|
|
|
char *full_path = NULL;
|
|
|
|
struct inode *inode = direntry->d_inode;
|
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
|
|
|
struct cifs_unix_set_info_args *args = NULL;
|
|
|
|
|
|
|
|
cFYI(1, ("setattr_unix on file %s attrs->ia_valid=0x%x",
|
|
|
|
direntry->d_name.name, attrs->ia_valid));
|
|
|
|
|
|
|
|
xid = GetXid();
|
|
|
|
|
|
|
|
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
|
|
|
|
/* check if we have permission to change attrs */
|
|
|
|
rc = inode_change_ok(inode, attrs);
|
|
|
|
if (rc < 0)
|
|
|
|
goto out;
|
|
|
|
else
|
|
|
|
rc = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
full_path = build_path_from_dentry(direntry);
|
|
|
|
if (full_path == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
|
|
|
|
/*
|
|
|
|
Flush data before changing file size or changing the last
|
|
|
|
write time of the file on the server. If the
|
|
|
|
flush returns error, store it to report later and continue.
|
|
|
|
BB: This should be smarter. Why bother flushing pages that
|
|
|
|
will be truncated anyway? Also, should we error out here if
|
|
|
|
the flush returns error?
|
|
|
|
*/
|
|
|
|
rc = filemap_write_and_wait(inode->i_mapping);
|
|
|
|
if (rc != 0) {
|
|
|
|
cifsInode->write_behind_rc = rc;
|
|
|
|
rc = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_SIZE) {
|
|
|
|
rc = cifs_set_file_size(inode, attrs, xid, full_path);
|
|
|
|
if (rc != 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip mode change if it's just for clearing setuid/setgid */
|
|
|
|
if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
|
|
|
|
attrs->ia_valid &= ~ATTR_MODE;
|
|
|
|
|
|
|
|
args = kmalloc(sizeof(*args), GFP_KERNEL);
|
|
|
|
if (args == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set up the struct */
|
|
|
|
if (attrs->ia_valid & ATTR_MODE)
|
|
|
|
args->mode = attrs->ia_mode;
|
|
|
|
else
|
|
|
|
args->mode = NO_CHANGE_64;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_UID)
|
|
|
|
args->uid = attrs->ia_uid;
|
|
|
|
else
|
|
|
|
args->uid = NO_CHANGE_64;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_GID)
|
|
|
|
args->gid = attrs->ia_gid;
|
|
|
|
else
|
|
|
|
args->gid = NO_CHANGE_64;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_ATIME)
|
|
|
|
args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
|
|
|
|
else
|
|
|
|
args->atime = NO_CHANGE_64;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_MTIME)
|
|
|
|
args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
|
|
|
|
else
|
|
|
|
args->mtime = NO_CHANGE_64;
|
|
|
|
|
|
|
|
if (attrs->ia_valid & ATTR_CTIME)
|
|
|
|
args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
|
|
|
|
else
|
|
|
|
args->ctime = NO_CHANGE_64;
|
|
|
|
|
|
|
|
args->device = 0;
|
|
|
|
rc = CIFSSMBUnixSetInfo(xid, pTcon, full_path, args,
|
|
|
|
cifs_sb->local_nls,
|
|
|
|
cifs_sb->mnt_cifs_flags &
|
|
|
|
CIFS_MOUNT_MAP_SPECIAL_CHR);
|
|
|
|
|
|
|
|
if (!rc)
|
|
|
|
rc = inode_setattr(inode, attrs);
|
|
|
|
out:
|
|
|
|
kfree(args);
|
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:26:12 +07:00
|
|
|
static int
|
|
|
|
cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int xid;
|
2008-08-02 18:26:12 +07:00
|
|
|
struct inode *inode = direntry->d_inode;
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
char *full_path = NULL;
|
|
|
|
int rc = -EACCES;
|
2008-08-02 18:26:12 +07:00
|
|
|
__u32 dosattr = 0;
|
2008-08-02 18:26:12 +07:00
|
|
|
__u64 mode = NO_CHANGE_64;
|
2008-08-02 18:26:12 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
xid = GetXid();
|
|
|
|
|
2006-06-01 05:40:51 +07:00
|
|
|
cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
|
2005-04-17 05:20:36 +07:00
|
|
|
direntry->d_name.name, attrs->ia_valid));
|
2005-11-30 11:20:10 +07:00
|
|
|
|
2005-11-30 12:22:19 +07:00
|
|
|
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
|
2005-11-30 11:20:10 +07:00
|
|
|
/* check if we have permission to change attrs */
|
2008-05-10 04:26:11 +07:00
|
|
|
rc = inode_change_ok(inode, attrs);
|
2007-07-10 08:16:18 +07:00
|
|
|
if (rc < 0) {
|
2005-11-30 11:20:10 +07:00
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
} else
|
|
|
|
rc = 0;
|
|
|
|
}
|
2007-07-13 07:33:32 +07:00
|
|
|
|
2005-08-31 01:32:14 +07:00
|
|
|
full_path = build_path_from_dentry(direntry);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (full_path == NULL) {
|
|
|
|
FreeXid(xid);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-03-15 02:21:31 +07:00
|
|
|
if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
/*
|
2008-03-15 02:21:31 +07:00
|
|
|
Flush data before changing file size or changing the last
|
|
|
|
write time of the file on the server. If the
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
flush returns error, store it to report later and continue.
|
|
|
|
BB: This should be smarter. Why bother flushing pages that
|
|
|
|
will be truncated anyway? Also, should we error out here if
|
|
|
|
the flush returns error?
|
|
|
|
*/
|
2008-05-10 04:26:11 +07:00
|
|
|
rc = filemap_write_and_wait(inode->i_mapping);
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
if (rc != 0) {
|
2008-05-10 04:26:11 +07:00
|
|
|
cifsInode->write_behind_rc = rc;
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
rc = 0;
|
|
|
|
}
|
2008-03-15 02:21:31 +07:00
|
|
|
}
|
[CIFS] Fix potential data corruption when writing out cached dirty pages
Fix RedHat bug 329431
The idea here is separate "conscious" from "unconscious" flushes.
Conscious flushes are those due to a fsync() or close(). Unconscious
ones are flushes that occur as a side effect of some other operation or
due to memory pressure.
Currently, when an error occurs during an unconscious flush (ENOSPC or
EIO), we toss out the page and don't preserve that error to report to
the user when a conscious flush occurs. If after the unconscious flush,
there are no more dirty pages for the inode, the conscious flush will
simply return success even though there were previous errors when writing
out pages. This can lead to data corruption.
The easiest way to reproduce this is to mount up a CIFS share that's
very close to being full or where the user is very close to quota. mv
a file to the share that's slightly larger than the quota allows. The
writes will all succeed (since they go to pagecache). The mv will do a
setattr to set the new file's attributes. This calls
filemap_write_and_wait,
which will return an error since all of the pages can't be written out.
Then later, when the flush and release ops occur, there are no more
dirty pages in pagecache for the file and those operations return 0. mv
then assumes that the file was written out correctly and deletes the
original.
CIFS already has a write_behind_rc variable where it stores the results
from earlier flushes, but that value is only reported in cifs_close.
Since the VFS ignores the return value from the release operation, this
isn't helpful. We should be reporting this error during the flush
operation.
This patch does the following:
1) changes cifs_fsync to use filemap_write_and_wait and cifs_flush and also
sync to check its return code. If it returns successful, they then check
the value of write_behind_rc to see if an earlier flush had reported any
errors. If so, they return that error and clear write_behind_rc.
2) sets write_behind_rc in a few other places where pages are written
out as a side effect of other operations and the code waits on them.
3) changes cifs_setattr to only call filemap_write_and_wait for
ATTR_SIZE changes.
4) makes cifs_writepages accurately distinguish between EIO and ENOSPC
errors when writing out pages.
Some simple testing indicates that the patch works as expected and that
it fixes the reproduceable known problem.
Acked-by: Dave Kleikamp <shaggy@austin.rr.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2007-11-21 06:19:03 +07:00
|
|
|
|
2008-03-15 02:21:31 +07:00
|
|
|
if (attrs->ia_valid & ATTR_SIZE) {
|
2008-07-24 04:28:12 +07:00
|
|
|
rc = cifs_set_file_size(inode, attrs, xid, full_path);
|
|
|
|
if (rc != 0)
|
2005-09-21 10:49:16 +07:00
|
|
|
goto cifs_setattr_exit;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-05-22 20:33:34 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Without unix extensions we can't send ownership changes to the
|
|
|
|
* server, so silently ignore them. This is consistent with how
|
|
|
|
* local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
|
|
|
|
* CIFSACL support + proper Windows to Unix idmapping, we may be
|
|
|
|
* able to support this in the future.
|
|
|
|
*/
|
2008-08-02 18:26:12 +07:00
|
|
|
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
|
2008-05-22 20:33:34 +07:00
|
|
|
attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-18 17:05:22 +07:00
|
|
|
/* skip mode change if it's just for clearing setuid/setgid */
|
|
|
|
if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
|
|
|
|
attrs->ia_valid &= ~ATTR_MODE;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (attrs->ia_valid & ATTR_MODE) {
|
2008-05-22 20:33:34 +07:00
|
|
|
cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
|
2005-04-17 05:20:36 +07:00
|
|
|
mode = attrs->ia_mode;
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:26:12 +07:00
|
|
|
if (attrs->ia_valid & ATTR_MODE) {
|
2005-11-20 12:04:52 +07:00
|
|
|
rc = 0;
|
2007-12-31 14:47:21 +07:00
|
|
|
#ifdef CONFIG_CIFS_EXPERIMENTAL
|
|
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
|
2008-05-10 04:26:11 +07:00
|
|
|
rc = mode_to_acl(inode, full_path, mode);
|
2008-05-22 20:33:34 +07:00
|
|
|
else
|
2007-12-31 14:47:21 +07:00
|
|
|
#endif
|
2008-05-22 20:33:34 +07:00
|
|
|
if (((mode & S_IWUGO) == 0) &&
|
|
|
|
(cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
|
2008-08-02 18:26:12 +07:00
|
|
|
|
|
|
|
dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
|
|
|
|
|
2008-05-22 20:33:34 +07:00
|
|
|
/* fix up mode if we're not using dynperm */
|
|
|
|
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
|
|
|
|
attrs->ia_mode = inode->i_mode & ~S_IWUGO;
|
|
|
|
} else if ((mode & S_IWUGO) &&
|
|
|
|
(cifsInode->cifsAttrs & ATTR_READONLY)) {
|
2008-08-02 18:26:12 +07:00
|
|
|
|
|
|
|
dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
|
|
|
|
/* Attributes of 0 are ignored */
|
|
|
|
if (dosattr == 0)
|
|
|
|
dosattr |= ATTR_NORMAL;
|
2008-05-22 20:33:34 +07:00
|
|
|
|
|
|
|
/* reset local inode permissions to normal */
|
|
|
|
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
|
|
|
|
attrs->ia_mode &= ~(S_IALLUGO);
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
attrs->ia_mode |=
|
|
|
|
cifs_sb->mnt_dir_mode;
|
|
|
|
else
|
|
|
|
attrs->ia_mode |=
|
|
|
|
cifs_sb->mnt_file_mode;
|
|
|
|
}
|
|
|
|
} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
|
|
|
|
/* ignore mode change - ATTR_READONLY hasn't changed */
|
|
|
|
attrs->ia_valid &= ~ATTR_MODE;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:26:12 +07:00
|
|
|
if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
|
|
|
|
((attrs->ia_valid & ATTR_MODE) && dosattr)) {
|
|
|
|
rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
|
|
|
|
/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-21 10:49:16 +07:00
|
|
|
/* Even if error on time set, no sense failing the call if
|
|
|
|
the server would set the time to a reasonable value anyway,
|
|
|
|
and this check ensures that we are not being called from
|
|
|
|
sys_utimes in which case we ought to fail the call back to
|
|
|
|
the user when the server rejects the call */
|
2007-07-10 08:16:18 +07:00
|
|
|
if ((rc) && (attrs->ia_valid &
|
2008-08-02 18:26:12 +07:00
|
|
|
(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
|
2005-09-21 10:49:16 +07:00
|
|
|
rc = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* do not need local check to inode_check_ok since the server does
|
|
|
|
that */
|
|
|
|
if (!rc)
|
2008-05-10 04:26:11 +07:00
|
|
|
rc = inode_setattr(inode, attrs);
|
2005-09-21 10:49:16 +07:00
|
|
|
cifs_setattr_exit:
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(full_path);
|
|
|
|
FreeXid(xid);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:26:12 +07:00
|
|
|
int
|
|
|
|
cifs_setattr(struct dentry *direntry, struct iattr *attrs)
|
|
|
|
{
|
|
|
|
struct inode *inode = direntry->d_inode;
|
|
|
|
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
|
|
|
|
struct cifsTconInfo *pTcon = cifs_sb->tcon;
|
|
|
|
|
|
|
|
if (pTcon->unix_ext)
|
|
|
|
return cifs_setattr_unix(direntry, attrs);
|
|
|
|
|
|
|
|
return cifs_setattr_nounix(direntry, attrs);
|
|
|
|
|
|
|
|
/* BB: add cifs_setattr_legacy for really old servers */
|
|
|
|
}
|
|
|
|
|
2007-02-27 12:35:17 +07:00
|
|
|
#if 0
|
2005-04-17 05:20:36 +07:00
|
|
|
void cifs_delete_inode(struct inode *inode)
|
|
|
|
{
|
2006-06-01 01:05:34 +07:00
|
|
|
cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
|
2005-04-17 05:20:36 +07:00
|
|
|
/* may have to add back in if and when safe distributed caching of
|
|
|
|
directories added e.g. via FindNotify */
|
|
|
|
}
|
2007-02-27 12:35:17 +07:00
|
|
|
#endif
|