1/*
   2 *   fs/cifs/inode.c
   3 *
   4 *   Copyright (C) International Business Machines  Corp., 2002,2010
   5 *   Author(s): Steve French (sfrench@us.ibm.com)
   6 *
   7 *   This library is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU Lesser General Public License as published
   9 *   by the Free Software Foundation; either version 2.1 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This library is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15 *   the GNU Lesser General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU Lesser General Public License
  18 *   along with this library; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 */
  21#include <linux/fs.h>
  22#include <linux/stat.h>
  23#include <linux/slab.h>
  24#include <linux/pagemap.h>
  25#include <linux/freezer.h>
 
 
 
 
  26#include <asm/div64.h>
  27#include "cifsfs.h"
  28#include "cifspdu.h"
  29#include "cifsglob.h"
  30#include "cifsproto.h"
 
  31#include "cifs_debug.h"
  32#include "cifs_fs_sb.h"
  33#include "cifs_unicode.h"
  34#include "fscache.h"
  35
  36
  37static void cifs_set_ops(struct inode *inode)
  38{
  39	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  40
  41	switch (inode->i_mode & S_IFMT) {
  42	case S_IFREG:
  43		inode->i_op = &cifs_file_inode_ops;
  44		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  45			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  46				inode->i_fop = &cifs_file_direct_nobrl_ops;
  47			else
  48				inode->i_fop = &cifs_file_direct_ops;
  49		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  50			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  51				inode->i_fop = &cifs_file_strict_nobrl_ops;
  52			else
  53				inode->i_fop = &cifs_file_strict_ops;
  54		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  55			inode->i_fop = &cifs_file_nobrl_ops;
  56		else { /* not direct, send byte range locks */
  57			inode->i_fop = &cifs_file_ops;
  58		}
  59
  60		/* check if server can support readpages */
  61		if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
  62				PAGE_SIZE + MAX_CIFS_HDR_SIZE)
  63			inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  64		else
  65			inode->i_data.a_ops = &cifs_addr_ops;
  66		break;
  67	case S_IFDIR:
  68#ifdef CONFIG_CIFS_DFS_UPCALL
  69		if (IS_AUTOMOUNT(inode)) {
  70			inode->i_op = &cifs_dfs_referral_inode_operations;
  71		} else {
  72#else /* NO DFS support, treat as a directory */
  73		{
  74#endif
  75			inode->i_op = &cifs_dir_inode_ops;
  76			inode->i_fop = &cifs_dir_ops;
  77		}
  78		break;
  79	case S_IFLNK:
  80		inode->i_op = &cifs_symlink_inode_ops;
  81		break;
  82	default:
  83		init_special_inode(inode, inode->i_mode, inode->i_rdev);
  84		break;
  85	}
  86}
  87
  88/* check inode attributes against fattr. If they don't match, tag the
  89 * inode for cache invalidation
  90 */
  91static void
  92cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  93{
  94	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  95
  96	cifs_dbg(FYI, "%s: revalidating inode %llu\n",
  97		 __func__, cifs_i->uniqueid);
  98
  99	if (inode->i_state & I_NEW) {
 100		cifs_dbg(FYI, "%s: inode %llu is new\n",
 101			 __func__, cifs_i->uniqueid);
 102		return;
 103	}
 104
 105	/* don't bother with revalidation if we have an oplock */
 106	if (CIFS_CACHE_READ(cifs_i)) {
 107		cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 108			 __func__, cifs_i->uniqueid);
 109		return;
 110	}
 111
 112	 /* revalidate if mtime or size have changed */
 113	if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 
 114	    cifs_i->server_eof == fattr->cf_eof) {
 115		cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 116			 __func__, cifs_i->uniqueid);
 117		return;
 118	}
 119
 120	cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 121		 __func__, cifs_i->uniqueid);
 122	set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 123}
 124
 125/*
 126 * copy nlink to the inode, unless it wasn't provided.  Provide
 127 * sane values if we don't have an existing one and none was provided
 128 */
 129static void
 130cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 131{
 132	/*
 133	 * if we're in a situation where we can't trust what we
 134	 * got from the server (readdir, some non-unix cases)
 135	 * fake reasonable values
 136	 */
 137	if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 138		/* only provide fake values on a new inode */
 139		if (inode->i_state & I_NEW) {
 140			if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 141				set_nlink(inode, 2);
 142			else
 143				set_nlink(inode, 1);
 144		}
 145		return;
 146	}
 147
 148	/* we trust the server, so update it */
 149	set_nlink(inode, fattr->cf_nlink);
 150}
 151
 152/* populate an inode with info from a cifs_fattr struct */
 153void
 154cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 155{
 156	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 157	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 158
 159	cifs_revalidate_cache(inode, fattr);
 160
 161	spin_lock(&inode->i_lock);
 162	inode->i_atime = fattr->cf_atime;
 
 
 
 
 
 
 
 163	inode->i_mtime = fattr->cf_mtime;
 164	inode->i_ctime = fattr->cf_ctime;
 165	inode->i_rdev = fattr->cf_rdev;
 166	cifs_nlink_fattr_to_inode(inode, fattr);
 167	inode->i_uid = fattr->cf_uid;
 168	inode->i_gid = fattr->cf_gid;
 169
 170	/* if dynperm is set, don't clobber existing mode */
 171	if (inode->i_state & I_NEW ||
 172	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 173		inode->i_mode = fattr->cf_mode;
 174
 175	cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 176
 177	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 178		cifs_i->time = 0;
 179	else
 180		cifs_i->time = jiffies;
 181
 182	if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
 183		set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 184	else
 185		clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 186
 187	cifs_i->server_eof = fattr->cf_eof;
 188	/*
 189	 * Can't safely change the file size here if the client is writing to
 190	 * it due to potential races.
 191	 */
 192	if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
 193		i_size_write(inode, fattr->cf_eof);
 194
 195		/*
 196		 * i_blocks is not related to (i_size / i_blksize),
 197		 * but instead 512 byte (2**9) size is required for
 198		 * calculating num blocks.
 199		 */
 200		inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 201	}
 202	spin_unlock(&inode->i_lock);
 203
 204	if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
 205		inode->i_flags |= S_AUTOMOUNT;
 206	if (inode->i_state & I_NEW)
 207		cifs_set_ops(inode);
 208}
 209
 210void
 211cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 212{
 213	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 214
 215	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 216		return;
 217
 218	fattr->cf_uniqueid = iunique(sb, ROOT_I);
 219}
 220
 221/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 222void
 223cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 224			 struct cifs_sb_info *cifs_sb)
 225{
 226	memset(fattr, 0, sizeof(*fattr));
 227	fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 228	fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 229	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 230
 231	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 232	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 233	fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 
 
 234	fattr->cf_mode = le64_to_cpu(info->Permissions);
 235
 236	/*
 237	 * Since we set the inode type below we need to mask off
 238	 * to avoid strange results if bits set above.
 239	 */
 240	fattr->cf_mode &= ~S_IFMT;
 241	switch (le32_to_cpu(info->Type)) {
 242	case UNIX_FILE:
 243		fattr->cf_mode |= S_IFREG;
 244		fattr->cf_dtype = DT_REG;
 245		break;
 246	case UNIX_SYMLINK:
 247		fattr->cf_mode |= S_IFLNK;
 248		fattr->cf_dtype = DT_LNK;
 249		break;
 250	case UNIX_DIR:
 251		fattr->cf_mode |= S_IFDIR;
 252		fattr->cf_dtype = DT_DIR;
 253		break;
 254	case UNIX_CHARDEV:
 255		fattr->cf_mode |= S_IFCHR;
 256		fattr->cf_dtype = DT_CHR;
 257		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 258				       le64_to_cpu(info->DevMinor) & MINORMASK);
 259		break;
 260	case UNIX_BLOCKDEV:
 261		fattr->cf_mode |= S_IFBLK;
 262		fattr->cf_dtype = DT_BLK;
 263		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 264				       le64_to_cpu(info->DevMinor) & MINORMASK);
 265		break;
 266	case UNIX_FIFO:
 267		fattr->cf_mode |= S_IFIFO;
 268		fattr->cf_dtype = DT_FIFO;
 269		break;
 270	case UNIX_SOCKET:
 271		fattr->cf_mode |= S_IFSOCK;
 272		fattr->cf_dtype = DT_SOCK;
 273		break;
 274	default:
 275		/* safest to call it a file if we do not know */
 276		fattr->cf_mode |= S_IFREG;
 277		fattr->cf_dtype = DT_REG;
 278		cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 279		break;
 280	}
 281
 282	fattr->cf_uid = cifs_sb->mnt_uid;
 283	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 284		u64 id = le64_to_cpu(info->Uid);
 285		if (id < ((uid_t)-1)) {
 286			kuid_t uid = make_kuid(&init_user_ns, id);
 287			if (uid_valid(uid))
 288				fattr->cf_uid = uid;
 289		}
 290	}
 291	
 292	fattr->cf_gid = cifs_sb->mnt_gid;
 293	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 294		u64 id = le64_to_cpu(info->Gid);
 295		if (id < ((gid_t)-1)) {
 296			kgid_t gid = make_kgid(&init_user_ns, id);
 297			if (gid_valid(gid))
 298				fattr->cf_gid = gid;
 299		}
 300	}
 301
 302	fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 303}
 304
 305/*
 306 * Fill a cifs_fattr struct with fake inode info.
 307 *
 308 * Needed to setup cifs_fattr data for the directory which is the
 309 * junction to the new submount (ie to setup the fake directory
 310 * which represents a DFS referral).
 311 */
 312static void
 313cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 314{
 315	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 316
 317	cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
 318
 319	memset(fattr, 0, sizeof(*fattr));
 320	fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 321	fattr->cf_uid = cifs_sb->mnt_uid;
 322	fattr->cf_gid = cifs_sb->mnt_gid;
 323	fattr->cf_atime = CURRENT_TIME;
 324	fattr->cf_ctime = CURRENT_TIME;
 325	fattr->cf_mtime = CURRENT_TIME;
 326	fattr->cf_nlink = 2;
 327	fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
 328}
 329
 330static int
 331cifs_get_file_info_unix(struct file *filp)
 332{
 333	int rc;
 334	unsigned int xid;
 335	FILE_UNIX_BASIC_INFO find_data;
 336	struct cifs_fattr fattr;
 337	struct inode *inode = file_inode(filp);
 338	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 339	struct cifsFileInfo *cfile = filp->private_data;
 340	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 341
 342	xid = get_xid();
 343	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 344	if (!rc) {
 345		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 346	} else if (rc == -EREMOTE) {
 347		cifs_create_dfs_fattr(&fattr, inode->i_sb);
 348		rc = 0;
 349	}
 350
 351	cifs_fattr_to_inode(inode, &fattr);
 352	free_xid(xid);
 353	return rc;
 354}
 355
 356int cifs_get_inode_info_unix(struct inode **pinode,
 357			     const unsigned char *full_path,
 358			     struct super_block *sb, unsigned int xid)
 359{
 360	int rc;
 361	FILE_UNIX_BASIC_INFO find_data;
 362	struct cifs_fattr fattr;
 363	struct cifs_tcon *tcon;
 364	struct tcon_link *tlink;
 365	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 366
 367	cifs_dbg(FYI, "Getting info on %s\n", full_path);
 368
 369	tlink = cifs_sb_tlink(cifs_sb);
 370	if (IS_ERR(tlink))
 371		return PTR_ERR(tlink);
 372	tcon = tlink_tcon(tlink);
 373
 374	/* could have done a find first instead but this returns more info */
 375	rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 376				  cifs_sb->local_nls, cifs_remap(cifs_sb));
 377	cifs_put_tlink(tlink);
 378
 379	if (!rc) {
 380		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 381	} else if (rc == -EREMOTE) {
 382		cifs_create_dfs_fattr(&fattr, sb);
 383		rc = 0;
 384	} else {
 385		return rc;
 386	}
 387
 388	/* check for Minshall+French symlinks */
 389	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 390		int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 391					     full_path);
 392		if (tmprc)
 393			cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 394	}
 395
 396	if (*pinode == NULL) {
 397		/* get new inode */
 398		cifs_fill_uniqueid(sb, &fattr);
 399		*pinode = cifs_iget(sb, &fattr);
 400		if (!*pinode)
 401			rc = -ENOMEM;
 402	} else {
 403		/* we already have inode, update it */
 404
 405		/* if uniqueid is different, return error */
 406		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 407		    CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
 
 408			rc = -ESTALE;
 409			goto cgiiu_exit;
 410		}
 411
 412		/* if filetype is different, return error */
 413		if (unlikely(((*pinode)->i_mode & S_IFMT) !=
 414		    (fattr.cf_mode & S_IFMT))) {
 
 415			rc = -ESTALE;
 416			goto cgiiu_exit;
 417		}
 418
 419		cifs_fattr_to_inode(*pinode, &fattr);
 420	}
 421
 422cgiiu_exit:
 423	return rc;
 424}
 425
 426static int
 427cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
 428	      struct cifs_sb_info *cifs_sb, unsigned int xid)
 429{
 430	int rc;
 431	__u32 oplock;
 432	struct tcon_link *tlink;
 433	struct cifs_tcon *tcon;
 434	struct cifs_fid fid;
 435	struct cifs_open_parms oparms;
 436	struct cifs_io_parms io_parms;
 437	char buf[24];
 438	unsigned int bytes_read;
 439	char *pbuf;
 440	int buf_type = CIFS_NO_BUFFER;
 441
 442	pbuf = buf;
 443
 444	fattr->cf_mode &= ~S_IFMT;
 445
 446	if (fattr->cf_eof == 0) {
 447		fattr->cf_mode |= S_IFIFO;
 448		fattr->cf_dtype = DT_FIFO;
 449		return 0;
 450	} else if (fattr->cf_eof < 8) {
 451		fattr->cf_mode |= S_IFREG;
 452		fattr->cf_dtype = DT_REG;
 453		return -EINVAL;	 /* EOPNOTSUPP? */
 454	}
 455
 456	tlink = cifs_sb_tlink(cifs_sb);
 457	if (IS_ERR(tlink))
 458		return PTR_ERR(tlink);
 459	tcon = tlink_tcon(tlink);
 460
 461	oparms.tcon = tcon;
 462	oparms.cifs_sb = cifs_sb;
 463	oparms.desired_access = GENERIC_READ;
 464	oparms.create_options = CREATE_NOT_DIR;
 465	oparms.disposition = FILE_OPEN;
 466	oparms.path = path;
 467	oparms.fid = &fid;
 468	oparms.reconnect = false;
 469
 470	if (tcon->ses->server->oplocks)
 471		oplock = REQ_OPLOCK;
 472	else
 473		oplock = 0;
 474	rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
 475	if (rc) {
 476		cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
 477		cifs_put_tlink(tlink);
 478		return rc;
 479	}
 480
 481	/* Read header */
 482	io_parms.netfid = fid.netfid;
 483	io_parms.pid = current->tgid;
 484	io_parms.tcon = tcon;
 485	io_parms.offset = 0;
 486	io_parms.length = 24;
 487
 488	rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
 489					&bytes_read, &pbuf, &buf_type);
 490	if ((rc == 0) && (bytes_read >= 8)) {
 491		if (memcmp("IntxBLK", pbuf, 8) == 0) {
 492			cifs_dbg(FYI, "Block device\n");
 493			fattr->cf_mode |= S_IFBLK;
 494			fattr->cf_dtype = DT_BLK;
 495			if (bytes_read == 24) {
 496				/* we have enough to decode dev num */
 497				__u64 mjr; /* major */
 498				__u64 mnr; /* minor */
 499				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 500				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 501				fattr->cf_rdev = MKDEV(mjr, mnr);
 502			}
 503		} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
 504			cifs_dbg(FYI, "Char device\n");
 505			fattr->cf_mode |= S_IFCHR;
 506			fattr->cf_dtype = DT_CHR;
 507			if (bytes_read == 24) {
 508				/* we have enough to decode dev num */
 509				__u64 mjr; /* major */
 510				__u64 mnr; /* minor */
 511				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 512				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 513				fattr->cf_rdev = MKDEV(mjr, mnr);
 514			}
 515		} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
 516			cifs_dbg(FYI, "Symlink\n");
 517			fattr->cf_mode |= S_IFLNK;
 518			fattr->cf_dtype = DT_LNK;
 519		} else {
 520			fattr->cf_mode |= S_IFREG; /* file? */
 521			fattr->cf_dtype = DT_REG;
 522			rc = -EOPNOTSUPP;
 523		}
 524	} else {
 525		fattr->cf_mode |= S_IFREG; /* then it is a file */
 526		fattr->cf_dtype = DT_REG;
 527		rc = -EOPNOTSUPP; /* or some unknown SFU type */
 528	}
 529
 530	tcon->ses->server->ops->close(xid, tcon, &fid);
 531	cifs_put_tlink(tlink);
 532	return rc;
 533}
 534
 535#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
 536
 537/*
 538 * Fetch mode bits as provided by SFU.
 539 *
 540 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
 541 */
 542static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
 543			 struct cifs_sb_info *cifs_sb, unsigned int xid)
 544{
 545#ifdef CONFIG_CIFS_XATTR
 546	ssize_t rc;
 547	char ea_value[4];
 548	__u32 mode;
 549	struct tcon_link *tlink;
 550	struct cifs_tcon *tcon;
 551
 552	tlink = cifs_sb_tlink(cifs_sb);
 553	if (IS_ERR(tlink))
 554		return PTR_ERR(tlink);
 555	tcon = tlink_tcon(tlink);
 556
 557	if (tcon->ses->server->ops->query_all_EAs == NULL) {
 558		cifs_put_tlink(tlink);
 559		return -EOPNOTSUPP;
 560	}
 561
 562	rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
 563			"SETFILEBITS", ea_value, 4 /* size of buf */,
 564			cifs_sb->local_nls,
 565			cifs_remap(cifs_sb));
 566	cifs_put_tlink(tlink);
 567	if (rc < 0)
 568		return (int)rc;
 569	else if (rc > 3) {
 570		mode = le32_to_cpu(*((__le32 *)ea_value));
 571		fattr->cf_mode &= ~SFBITS_MASK;
 572		cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
 573			 mode, fattr->cf_mode);
 574		fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
 575		cifs_dbg(FYI, "special mode bits 0%o\n", mode);
 576	}
 577
 578	return 0;
 579#else
 580	return -EOPNOTSUPP;
 581#endif
 582}
 583
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 584/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
 585static void
 586cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
 587		       struct cifs_sb_info *cifs_sb, bool adjust_tz,
 588		       bool symlink)
 589{
 
 590	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 591
 592	memset(fattr, 0, sizeof(*fattr));
 593	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
 594	if (info->DeletePending)
 595		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
 596
 597	if (info->LastAccessTime)
 598		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 599	else
 600		fattr->cf_atime = CURRENT_TIME;
 601
 602	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 603	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
 604
 605	if (adjust_tz) {
 606		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
 607		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
 608	}
 609
 610	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 611	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
 612	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
 613
 614	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
 615
 616	if (symlink) {
 617		fattr->cf_mode = S_IFLNK;
 618		fattr->cf_dtype = DT_LNK;
 619	} else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
 620		fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
 621		fattr->cf_dtype = DT_DIR;
 622		/*
 623		 * Server can return wrong NumberOfLinks value for directories
 624		 * when Unix extensions are disabled - fake it.
 625		 */
 626		if (!tcon->unix_ext)
 627			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 628	} else {
 629		fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
 630		fattr->cf_dtype = DT_REG;
 631
 632		/* clear write bits if ATTR_READONLY is set */
 633		if (fattr->cf_cifsattrs & ATTR_READONLY)
 634			fattr->cf_mode &= ~(S_IWUGO);
 635
 636		/*
 637		 * Don't accept zero nlink from non-unix servers unless
 638		 * delete is pending.  Instead mark it as unknown.
 639		 */
 640		if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
 641		    !info->DeletePending) {
 642			cifs_dbg(1, "bogus file nlink value %u\n",
 643				fattr->cf_nlink);
 644			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 645		}
 646	}
 647
 648	fattr->cf_uid = cifs_sb->mnt_uid;
 649	fattr->cf_gid = cifs_sb->mnt_gid;
 650}
 651
 652static int
 653cifs_get_file_info(struct file *filp)
 654{
 655	int rc;
 656	unsigned int xid;
 657	FILE_ALL_INFO find_data;
 658	struct cifs_fattr fattr;
 659	struct inode *inode = file_inode(filp);
 660	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 661	struct cifsFileInfo *cfile = filp->private_data;
 662	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 663	struct TCP_Server_Info *server = tcon->ses->server;
 664
 665	if (!server->ops->query_file_info)
 666		return -ENOSYS;
 667
 668	xid = get_xid();
 669	rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
 670	switch (rc) {
 671	case 0:
 672		cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
 673				       false);
 674		break;
 675	case -EREMOTE:
 676		cifs_create_dfs_fattr(&fattr, inode->i_sb);
 677		rc = 0;
 678		break;
 679	case -EOPNOTSUPP:
 680	case -EINVAL:
 681		/*
 682		 * FIXME: legacy server -- fall back to path-based call?
 683		 * for now, just skip revalidating and mark inode for
 684		 * immediate reval.
 685		 */
 686		rc = 0;
 687		CIFS_I(inode)->time = 0;
 688	default:
 689		goto cgfi_exit;
 690	}
 691
 692	/*
 693	 * don't bother with SFU junk here -- just mark inode as needing
 694	 * revalidation.
 695	 */
 696	fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
 697	fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
 698	cifs_fattr_to_inode(inode, &fattr);
 699cgfi_exit:
 700	free_xid(xid);
 701	return rc;
 702}
 703
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 704int
 705cifs_get_inode_info(struct inode **inode, const char *full_path,
 706		    FILE_ALL_INFO *data, struct super_block *sb, int xid,
 
 
 707		    const struct cifs_fid *fid)
 708{
 709	bool validinum = false;
 710	__u16 srchflgs;
 711	int rc = 0, tmprc = ENOSYS;
 712	struct cifs_tcon *tcon;
 713	struct TCP_Server_Info *server;
 714	struct tcon_link *tlink;
 715	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 716	char *buf = NULL;
 717	bool adjust_tz = false;
 718	struct cifs_fattr fattr;
 719	struct cifs_search_info *srchinf = NULL;
 720	bool symlink = false;
 
 
 
 
 
 721
 722	tlink = cifs_sb_tlink(cifs_sb);
 723	if (IS_ERR(tlink))
 724		return PTR_ERR(tlink);
 725	tcon = tlink_tcon(tlink);
 726	server = tcon->ses->server;
 727
 728	cifs_dbg(FYI, "Getting info on %s\n", full_path);
 
 
 729
 730	if ((data == NULL) && (*inode != NULL)) {
 731		if (CIFS_CACHE_READ(CIFS_I(*inode))) {
 732			cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
 733			goto cgii_exit;
 734		}
 735	}
 736
 737	/* if inode info is not passed, get it from server */
 738	if (data == NULL) {
 739		if (!server->ops->query_path_info) {
 740			rc = -ENOSYS;
 741			goto cgii_exit;
 742		}
 743		buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 744		if (buf == NULL) {
 745			rc = -ENOMEM;
 746			goto cgii_exit;
 747		}
 748		data = (FILE_ALL_INFO *)buf;
 749		rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
 750						  data, &adjust_tz, &symlink);
 
 751	}
 752
 753	if (!rc) {
 754		cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
 755				       symlink);
 756	} else if (rc == -EREMOTE) {
 
 
 
 
 
 
 757		cifs_create_dfs_fattr(&fattr, sb);
 758		rc = 0;
 759	} else if (rc == -EACCES && backup_cred(cifs_sb)) {
 760			srchinf = kzalloc(sizeof(struct cifs_search_info),
 761						GFP_KERNEL);
 762			if (srchinf == NULL) {
 763				rc = -ENOMEM;
 764				goto cgii_exit;
 765			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 766
 767			srchinf->endOfSearch = false;
 768			srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 769
 770			srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
 771					CIFS_SEARCH_CLOSE_AT_END |
 772					CIFS_SEARCH_BACKUP_SEARCH;
 773
 774			rc = CIFSFindFirst(xid, tcon, full_path,
 775				cifs_sb, NULL, srchflgs, srchinf, false);
 776			if (!rc) {
 777				data =
 778				(FILE_ALL_INFO *)srchinf->srch_entries_start;
 779
 780				cifs_dir_info_to_fattr(&fattr,
 781				(FILE_DIRECTORY_INFO *)data, cifs_sb);
 782				fattr.cf_uniqueid = le64_to_cpu(
 783				((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
 784				validinum = true;
 785
 786				cifs_buf_release(srchinf->ntwrk_buf_start);
 787			}
 788			kfree(srchinf);
 789			if (rc)
 790				goto cgii_exit;
 791	} else
 792		goto cgii_exit;
 793
 794	/*
 795	 * If an inode wasn't passed in, then get the inode number
 796	 *
 797	 * Is an i_ino of zero legal? Can we use that to check if the server
 798	 * supports returning inode numbers?  Are there other sanity checks we
 799	 * can use to ensure that the server is really filling in that field?
 800	 */
 801	if (*inode == NULL) {
 802		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 803			if (validinum == false) {
 804				if (server->ops->get_srv_inum)
 805					tmprc = server->ops->get_srv_inum(xid,
 806						tcon, cifs_sb, full_path,
 807						&fattr.cf_uniqueid, data);
 808				if (tmprc) {
 809					cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
 810						 tmprc);
 811					fattr.cf_uniqueid = iunique(sb, ROOT_I);
 812					cifs_autodisable_serverino(cifs_sb);
 813				}
 814			}
 815		} else
 816			fattr.cf_uniqueid = iunique(sb, ROOT_I);
 817	} else {
 818		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
 819		    validinum == false && server->ops->get_srv_inum) {
 820			/*
 821			 * Pass a NULL tcon to ensure we don't make a round
 822			 * trip to the server. This only works for SMB2+.
 823			 */
 824			tmprc = server->ops->get_srv_inum(xid,
 825				NULL, cifs_sb, full_path,
 826				&fattr.cf_uniqueid, data);
 827			if (tmprc)
 828				fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 829		} else
 830			fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 831	}
 832
 
 833	/* query for SFU type info if supported and needed */
 834	if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
 835	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
 836		tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
 837		if (tmprc)
 838			cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
 839	}
 840
 841#ifdef CONFIG_CIFS_ACL
 842	/* fill in 0777 bits from ACL */
 843	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 844		rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
 
 
 
 
 
 
 
 
 
 
 
 
 
 845		if (rc) {
 846			cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
 847				 __func__, rc);
 848			goto cgii_exit;
 849		}
 850	}
 851#endif /* CONFIG_CIFS_ACL */
 852
 853	/* fill in remaining high mode bits e.g. SUID, VTX */
 854	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 855		cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
 856
 857	/* check for Minshall+French symlinks */
 858	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 859		tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 860					 full_path);
 861		if (tmprc)
 862			cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 863	}
 864
 
 
 
 
 865	if (!*inode) {
 866		*inode = cifs_iget(sb, &fattr);
 867		if (!*inode)
 868			rc = -ENOMEM;
 869	} else {
 870		/* we already have inode, update it */
 871
 872		/* if uniqueid is different, return error */
 873		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 874		    CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
 
 875			rc = -ESTALE;
 876			goto cgii_exit;
 877		}
 878
 879		/* if filetype is different, return error */
 880		if (unlikely(((*inode)->i_mode & S_IFMT) !=
 881		    (fattr.cf_mode & S_IFMT))) {
 
 882			rc = -ESTALE;
 883			goto cgii_exit;
 884		}
 885
 886		cifs_fattr_to_inode(*inode, &fattr);
 887	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 888
 889cgii_exit:
 890	kfree(buf);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 891	cifs_put_tlink(tlink);
 
 892	return rc;
 893}
 894
 
 895static const struct inode_operations cifs_ipc_inode_ops = {
 896	.lookup = cifs_lookup,
 897};
 898
 899static int
 900cifs_find_inode(struct inode *inode, void *opaque)
 901{
 902	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 903
 904	/* don't match inode with different uniqueid */
 905	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
 906		return 0;
 907
 908	/* use createtime like an i_generation field */
 909	if (CIFS_I(inode)->createtime != fattr->cf_createtime)
 910		return 0;
 911
 912	/* don't match inode of different type */
 913	if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
 914		return 0;
 915
 916	/* if it's not a directory or has no dentries, then flag it */
 917	if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
 918		fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
 919
 920	return 1;
 921}
 922
 923static int
 924cifs_init_inode(struct inode *inode, void *opaque)
 925{
 926	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 927
 928	CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
 929	CIFS_I(inode)->createtime = fattr->cf_createtime;
 930	return 0;
 931}
 932
 933/*
 934 * walk dentry list for an inode and report whether it has aliases that
 935 * are hashed. We use this to determine if a directory inode can actually
 936 * be used.
 937 */
 938static bool
 939inode_has_hashed_dentries(struct inode *inode)
 940{
 941	struct dentry *dentry;
 942
 943	spin_lock(&inode->i_lock);
 944	hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
 945		if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
 946			spin_unlock(&inode->i_lock);
 947			return true;
 948		}
 949	}
 950	spin_unlock(&inode->i_lock);
 951	return false;
 952}
 953
 954/* Given fattrs, get a corresponding inode */
 955struct inode *
 956cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
 957{
 958	unsigned long hash;
 959	struct inode *inode;
 960
 961retry_iget5_locked:
 962	cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
 963
 964	/* hash down to 32-bits on 32-bit arch */
 965	hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
 966
 967	inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
 968	if (inode) {
 969		/* was there a potentially problematic inode collision? */
 970		if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
 971			fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
 972
 973			if (inode_has_hashed_dentries(inode)) {
 974				cifs_autodisable_serverino(CIFS_SB(sb));
 975				iput(inode);
 976				fattr->cf_uniqueid = iunique(sb, ROOT_I);
 977				goto retry_iget5_locked;
 978			}
 979		}
 980
 981		cifs_fattr_to_inode(inode, fattr);
 982		if (sb->s_flags & MS_NOATIME)
 983			inode->i_flags |= S_NOATIME | S_NOCMTIME;
 984		if (inode->i_state & I_NEW) {
 985			inode->i_ino = hash;
 986#ifdef CONFIG_CIFS_FSCACHE
 987			/* initialize per-inode cache cookie pointer */
 988			CIFS_I(inode)->fscache = NULL;
 989#endif
 990			unlock_new_inode(inode);
 991		}
 992	}
 993
 994	return inode;
 995}
 996
 997/* gets root inode */
 998struct inode *cifs_root_iget(struct super_block *sb)
 999{
1000	unsigned int xid;
1001	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1002	struct inode *inode = NULL;
1003	long rc;
1004	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1005
1006	xid = get_xid();
1007	if (tcon->unix_ext) {
1008		rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
1009		/* some servers mistakenly claim POSIX support */
1010		if (rc != -EOPNOTSUPP)
1011			goto iget_no_retry;
1012		cifs_dbg(VFS, "server does not support POSIX extensions");
1013		tcon->unix_ext = false;
1014	}
1015
1016	rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
 
 
 
 
1017
1018iget_no_retry:
1019	if (!inode) {
1020		inode = ERR_PTR(rc);
1021		goto out;
1022	}
1023
1024#ifdef CONFIG_CIFS_FSCACHE
1025	/* populate tcon->resource_id */
1026	tcon->resource_id = CIFS_I(inode)->uniqueid;
1027#endif
1028
1029	if (rc && tcon->ipc) {
1030		cifs_dbg(FYI, "ipc connection - fake read inode\n");
1031		spin_lock(&inode->i_lock);
1032		inode->i_mode |= S_IFDIR;
1033		set_nlink(inode, 2);
1034		inode->i_op = &cifs_ipc_inode_ops;
1035		inode->i_fop = &simple_dir_operations;
1036		inode->i_uid = cifs_sb->mnt_uid;
1037		inode->i_gid = cifs_sb->mnt_gid;
1038		spin_unlock(&inode->i_lock);
1039	} else if (rc) {
1040		iget_failed(inode);
1041		inode = ERR_PTR(rc);
1042	}
1043
1044out:
1045	/* can not call macro free_xid here since in a void func
1046	 * TODO: This is no longer true
1047	 */
1048	_free_xid(xid);
1049	return inode;
1050}
1051
1052int
1053cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1054		   char *full_path, __u32 dosattr)
1055{
1056	bool set_time = false;
1057	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1058	struct TCP_Server_Info *server;
1059	FILE_BASIC_INFO	info_buf;
1060
1061	if (attrs == NULL)
1062		return -EINVAL;
1063
1064	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1065	if (!server->ops->set_file_info)
1066		return -ENOSYS;
1067
 
 
1068	if (attrs->ia_valid & ATTR_ATIME) {
1069		set_time = true;
1070		info_buf.LastAccessTime =
1071			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1072	} else
1073		info_buf.LastAccessTime = 0;
1074
1075	if (attrs->ia_valid & ATTR_MTIME) {
1076		set_time = true;
1077		info_buf.LastWriteTime =
1078		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1079	} else
1080		info_buf.LastWriteTime = 0;
1081
1082	/*
1083	 * Samba throws this field away, but windows may actually use it.
1084	 * Do not set ctime unless other time stamps are changed explicitly
1085	 * (i.e. by utimes()) since we would then have a mix of client and
1086	 * server times.
1087	 */
1088	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1089		cifs_dbg(FYI, "CIFS - CTIME changed\n");
1090		info_buf.ChangeTime =
1091		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1092	} else
1093		info_buf.ChangeTime = 0;
1094
1095	info_buf.CreationTime = 0;	/* don't change */
1096	info_buf.Attributes = cpu_to_le32(dosattr);
1097
1098	return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1099}
1100
1101/*
1102 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1103 * and rename it to a random name that hopefully won't conflict with
1104 * anything else.
1105 */
1106int
1107cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1108			   const unsigned int xid)
1109{
1110	int oplock = 0;
1111	int rc;
1112	struct cifs_fid fid;
1113	struct cifs_open_parms oparms;
1114	struct inode *inode = d_inode(dentry);
1115	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1116	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1117	struct tcon_link *tlink;
1118	struct cifs_tcon *tcon;
1119	__u32 dosattr, origattr;
1120	FILE_BASIC_INFO *info_buf = NULL;
1121
1122	tlink = cifs_sb_tlink(cifs_sb);
1123	if (IS_ERR(tlink))
1124		return PTR_ERR(tlink);
1125	tcon = tlink_tcon(tlink);
1126
1127	/*
1128	 * We cannot rename the file if the server doesn't support
1129	 * CAP_INFOLEVEL_PASSTHRU
1130	 */
1131	if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1132		rc = -EBUSY;
1133		goto out;
1134	}
1135
1136	oparms.tcon = tcon;
1137	oparms.cifs_sb = cifs_sb;
1138	oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1139	oparms.create_options = CREATE_NOT_DIR;
1140	oparms.disposition = FILE_OPEN;
1141	oparms.path = full_path;
1142	oparms.fid = &fid;
1143	oparms.reconnect = false;
1144
1145	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1146	if (rc != 0)
1147		goto out;
1148
1149	origattr = cifsInode->cifsAttrs;
1150	if (origattr == 0)
1151		origattr |= ATTR_NORMAL;
1152
1153	dosattr = origattr & ~ATTR_READONLY;
1154	if (dosattr == 0)
1155		dosattr |= ATTR_NORMAL;
1156	dosattr |= ATTR_HIDDEN;
1157
1158	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1159	if (dosattr != origattr) {
1160		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1161		if (info_buf == NULL) {
1162			rc = -ENOMEM;
1163			goto out_close;
1164		}
1165		info_buf->Attributes = cpu_to_le32(dosattr);
1166		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1167					current->tgid);
1168		/* although we would like to mark the file hidden
1169 		   if that fails we will still try to rename it */
1170		if (!rc)
1171			cifsInode->cifsAttrs = dosattr;
1172		else
1173			dosattr = origattr; /* since not able to change them */
1174	}
1175
1176	/* rename the file */
1177	rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1178				   cifs_sb->local_nls,
1179				   cifs_remap(cifs_sb));
1180	if (rc != 0) {
1181		rc = -EBUSY;
1182		goto undo_setattr;
1183	}
1184
1185	/* try to set DELETE_ON_CLOSE */
1186	if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1187		rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1188					       current->tgid);
1189		/*
1190		 * some samba versions return -ENOENT when we try to set the
1191		 * file disposition here. Likely a samba bug, but work around
1192		 * it for now. This means that some cifsXXX files may hang
1193		 * around after they shouldn't.
1194		 *
1195		 * BB: remove this hack after more servers have the fix
1196		 */
1197		if (rc == -ENOENT)
1198			rc = 0;
1199		else if (rc != 0) {
1200			rc = -EBUSY;
1201			goto undo_rename;
1202		}
1203		set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1204	}
1205
1206out_close:
1207	CIFSSMBClose(xid, tcon, fid.netfid);
1208out:
1209	kfree(info_buf);
1210	cifs_put_tlink(tlink);
1211	return rc;
1212
1213	/*
1214	 * reset everything back to the original state. Don't bother
1215	 * dealing with errors here since we can't do anything about
1216	 * them anyway.
1217	 */
1218undo_rename:
1219	CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1220				cifs_sb->local_nls, cifs_remap(cifs_sb));
1221undo_setattr:
1222	if (dosattr != origattr) {
1223		info_buf->Attributes = cpu_to_le32(origattr);
1224		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1225					current->tgid))
1226			cifsInode->cifsAttrs = origattr;
1227	}
1228
1229	goto out_close;
1230}
1231
1232/* copied from fs/nfs/dir.c with small changes */
1233static void
1234cifs_drop_nlink(struct inode *inode)
1235{
1236	spin_lock(&inode->i_lock);
1237	if (inode->i_nlink > 0)
1238		drop_nlink(inode);
1239	spin_unlock(&inode->i_lock);
1240}
1241
1242/*
1243 * If d_inode(dentry) is null (usually meaning the cached dentry
1244 * is a negative dentry) then we would attempt a standard SMB delete, but
1245 * if that fails we can not attempt the fall back mechanisms on EACCESS
1246 * but will return the EACCESS to the caller. Note that the VFS does not call
1247 * unlink on negative dentries currently.
1248 */
1249int cifs_unlink(struct inode *dir, struct dentry *dentry)
1250{
1251	int rc = 0;
1252	unsigned int xid;
1253	char *full_path = NULL;
1254	struct inode *inode = d_inode(dentry);
1255	struct cifsInodeInfo *cifs_inode;
1256	struct super_block *sb = dir->i_sb;
1257	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1258	struct tcon_link *tlink;
1259	struct cifs_tcon *tcon;
1260	struct TCP_Server_Info *server;
1261	struct iattr *attrs = NULL;
1262	__u32 dosattr = 0, origattr = 0;
1263
1264	cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1265
1266	tlink = cifs_sb_tlink(cifs_sb);
1267	if (IS_ERR(tlink))
1268		return PTR_ERR(tlink);
1269	tcon = tlink_tcon(tlink);
1270	server = tcon->ses->server;
1271
1272	xid = get_xid();
1273
 
 
 
 
 
1274	/* Unlink can be called from rename so we can not take the
1275	 * sb->s_vfs_rename_mutex here */
1276	full_path = build_path_from_dentry(dentry);
1277	if (full_path == NULL) {
1278		rc = -ENOMEM;
1279		goto unlink_out;
1280	}
1281
1282	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1283				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1284		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1285			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1286			cifs_remap(cifs_sb));
1287		cifs_dbg(FYI, "posix del rc %d\n", rc);
1288		if ((rc == 0) || (rc == -ENOENT))
1289			goto psx_del_no_retry;
1290	}
1291
1292retry_std_delete:
1293	if (!server->ops->unlink) {
1294		rc = -ENOSYS;
1295		goto psx_del_no_retry;
1296	}
1297
1298	rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1299
1300psx_del_no_retry:
1301	if (!rc) {
1302		if (inode)
1303			cifs_drop_nlink(inode);
1304	} else if (rc == -ENOENT) {
1305		d_drop(dentry);
1306	} else if (rc == -EBUSY) {
1307		if (server->ops->rename_pending_delete) {
1308			rc = server->ops->rename_pending_delete(full_path,
1309								dentry, xid);
1310			if (rc == 0)
1311				cifs_drop_nlink(inode);
1312		}
1313	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1314		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1315		if (attrs == NULL) {
1316			rc = -ENOMEM;
1317			goto out_reval;
1318		}
1319
1320		/* try to reset dos attributes */
1321		cifs_inode = CIFS_I(inode);
1322		origattr = cifs_inode->cifsAttrs;
1323		if (origattr == 0)
1324			origattr |= ATTR_NORMAL;
1325		dosattr = origattr & ~ATTR_READONLY;
1326		if (dosattr == 0)
1327			dosattr |= ATTR_NORMAL;
1328		dosattr |= ATTR_HIDDEN;
1329
1330		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1331		if (rc != 0)
1332			goto out_reval;
1333
1334		goto retry_std_delete;
1335	}
1336
1337	/* undo the setattr if we errored out and it's needed */
1338	if (rc != 0 && dosattr != 0)
1339		cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1340
1341out_reval:
1342	if (inode) {
1343		cifs_inode = CIFS_I(inode);
1344		cifs_inode->time = 0;	/* will force revalidate to get info
1345					   when needed */
1346		inode->i_ctime = current_fs_time(sb);
1347	}
1348	dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1349	cifs_inode = CIFS_I(dir);
1350	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */
1351unlink_out:
1352	kfree(full_path);
1353	kfree(attrs);
1354	free_xid(xid);
1355	cifs_put_tlink(tlink);
1356	return rc;
1357}
1358
1359static int
1360cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1361		 const char *full_path, struct cifs_sb_info *cifs_sb,
1362		 struct cifs_tcon *tcon, const unsigned int xid)
1363{
1364	int rc = 0;
1365	struct inode *inode = NULL;
1366
1367	if (tcon->unix_ext)
 
 
1368		rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1369					      xid);
1370	else
1371		rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1372					 xid, NULL);
1373
1374	if (rc)
1375		return rc;
1376
1377	/*
1378	 * setting nlink not necessary except in cases where we failed to get it
1379	 * from the server or was set bogus. Also, since this is a brand new
1380	 * inode, no need to grab the i_lock before setting the i_nlink.
1381	 */
1382	if (inode->i_nlink < 2)
1383		set_nlink(inode, 2);
1384	mode &= ~current_umask();
1385	/* must turn on setgid bit if parent dir has it */
1386	if (parent->i_mode & S_ISGID)
1387		mode |= S_ISGID;
1388
1389	if (tcon->unix_ext) {
1390		struct cifs_unix_set_info_args args = {
1391			.mode	= mode,
1392			.ctime	= NO_CHANGE_64,
1393			.atime	= NO_CHANGE_64,
1394			.mtime	= NO_CHANGE_64,
1395			.device	= 0,
1396		};
1397		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1398			args.uid = current_fsuid();
1399			if (parent->i_mode & S_ISGID)
1400				args.gid = parent->i_gid;
1401			else
1402				args.gid = current_fsgid();
1403		} else {
1404			args.uid = INVALID_UID; /* no change */
1405			args.gid = INVALID_GID; /* no change */
1406		}
1407		CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1408				       cifs_sb->local_nls,
1409				       cifs_remap(cifs_sb));
1410	} else {
1411		struct TCP_Server_Info *server = tcon->ses->server;
1412		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1413		    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1414			server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1415						   tcon, xid);
1416		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1417			inode->i_mode = (mode | S_IFDIR);
1418
1419		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1420			inode->i_uid = current_fsuid();
1421			if (inode->i_mode & S_ISGID)
1422				inode->i_gid = parent->i_gid;
1423			else
1424				inode->i_gid = current_fsgid();
1425		}
1426	}
1427	d_instantiate(dentry, inode);
1428	return rc;
1429}
1430
1431static int
1432cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1433		 const char *full_path, struct cifs_sb_info *cifs_sb,
1434		 struct cifs_tcon *tcon, const unsigned int xid)
1435{
1436	int rc = 0;
1437	u32 oplock = 0;
1438	FILE_UNIX_BASIC_INFO *info = NULL;
1439	struct inode *newinode = NULL;
1440	struct cifs_fattr fattr;
1441
1442	info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1443	if (info == NULL) {
1444		rc = -ENOMEM;
1445		goto posix_mkdir_out;
1446	}
1447
1448	mode &= ~current_umask();
1449	rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1450			     NULL /* netfid */, info, &oplock, full_path,
1451			     cifs_sb->local_nls, cifs_remap(cifs_sb));
1452	if (rc == -EOPNOTSUPP)
1453		goto posix_mkdir_out;
1454	else if (rc) {
1455		cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1456		d_drop(dentry);
1457		goto posix_mkdir_out;
1458	}
1459
1460	if (info->Type == cpu_to_le32(-1))
1461		/* no return info, go query for it */
1462		goto posix_mkdir_get_info;
1463	/*
1464	 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1465	 * need to set uid/gid.
1466	 */
1467
1468	cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1469	cifs_fill_uniqueid(inode->i_sb, &fattr);
1470	newinode = cifs_iget(inode->i_sb, &fattr);
1471	if (!newinode)
1472		goto posix_mkdir_get_info;
1473
1474	d_instantiate(dentry, newinode);
1475
1476#ifdef CONFIG_CIFS_DEBUG2
1477	cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1478		 dentry, dentry, newinode);
1479
1480	if (newinode->i_nlink != 2)
1481		cifs_dbg(FYI, "unexpected number of links %d\n",
1482			 newinode->i_nlink);
1483#endif
1484
1485posix_mkdir_out:
1486	kfree(info);
1487	return rc;
1488posix_mkdir_get_info:
1489	rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1490			      xid);
1491	goto posix_mkdir_out;
1492}
1493
1494int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1495{
1496	int rc = 0;
1497	unsigned int xid;
1498	struct cifs_sb_info *cifs_sb;
1499	struct tcon_link *tlink;
1500	struct cifs_tcon *tcon;
1501	struct TCP_Server_Info *server;
1502	char *full_path;
1503
1504	cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1505		 mode, inode);
1506
1507	cifs_sb = CIFS_SB(inode->i_sb);
1508	tlink = cifs_sb_tlink(cifs_sb);
1509	if (IS_ERR(tlink))
1510		return PTR_ERR(tlink);
1511	tcon = tlink_tcon(tlink);
1512
1513	xid = get_xid();
1514
1515	full_path = build_path_from_dentry(direntry);
1516	if (full_path == NULL) {
1517		rc = -ENOMEM;
1518		goto mkdir_out;
1519	}
1520
 
 
 
 
 
 
 
 
 
1521	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1522				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1523		rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1524				      tcon, xid);
1525		if (rc != -EOPNOTSUPP)
1526			goto mkdir_out;
1527	}
1528
1529	server = tcon->ses->server;
1530
1531	if (!server->ops->mkdir) {
1532		rc = -ENOSYS;
1533		goto mkdir_out;
1534	}
1535
1536	/* BB add setting the equivalent of mode via CreateX w/ACLs */
1537	rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1538	if (rc) {
1539		cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1540		d_drop(direntry);
1541		goto mkdir_out;
1542	}
1543
 
1544	rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1545			      xid);
1546mkdir_out:
1547	/*
1548	 * Force revalidate to get parent dir info when needed since cached
1549	 * attributes are invalid now.
1550	 */
1551	CIFS_I(inode)->time = 0;
1552	kfree(full_path);
1553	free_xid(xid);
1554	cifs_put_tlink(tlink);
1555	return rc;
1556}
1557
1558int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1559{
1560	int rc = 0;
1561	unsigned int xid;
1562	struct cifs_sb_info *cifs_sb;
1563	struct tcon_link *tlink;
1564	struct cifs_tcon *tcon;
1565	struct TCP_Server_Info *server;
1566	char *full_path = NULL;
1567	struct cifsInodeInfo *cifsInode;
1568
1569	cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1570
1571	xid = get_xid();
1572
1573	full_path = build_path_from_dentry(direntry);
1574	if (full_path == NULL) {
1575		rc = -ENOMEM;
1576		goto rmdir_exit;
1577	}
1578
1579	cifs_sb = CIFS_SB(inode->i_sb);
1580	tlink = cifs_sb_tlink(cifs_sb);
1581	if (IS_ERR(tlink)) {
1582		rc = PTR_ERR(tlink);
1583		goto rmdir_exit;
1584	}
1585	tcon = tlink_tcon(tlink);
1586	server = tcon->ses->server;
1587
1588	if (!server->ops->rmdir) {
1589		rc = -ENOSYS;
1590		cifs_put_tlink(tlink);
1591		goto rmdir_exit;
1592	}
1593
 
 
 
 
 
 
1594	rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1595	cifs_put_tlink(tlink);
1596
1597	if (!rc) {
1598		spin_lock(&d_inode(direntry)->i_lock);
1599		i_size_write(d_inode(direntry), 0);
1600		clear_nlink(d_inode(direntry));
1601		spin_unlock(&d_inode(direntry)->i_lock);
1602	}
1603
1604	cifsInode = CIFS_I(d_inode(direntry));
1605	/* force revalidate to go get info when needed */
1606	cifsInode->time = 0;
1607
1608	cifsInode = CIFS_I(inode);
1609	/*
1610	 * Force revalidate to get parent dir info when needed since cached
1611	 * attributes are invalid now.
1612	 */
1613	cifsInode->time = 0;
1614
1615	d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1616		current_fs_time(inode->i_sb);
1617
1618rmdir_exit:
1619	kfree(full_path);
1620	free_xid(xid);
1621	return rc;
1622}
1623
1624static int
1625cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1626	       const char *from_path, struct dentry *to_dentry,
1627	       const char *to_path)
1628{
1629	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1630	struct tcon_link *tlink;
1631	struct cifs_tcon *tcon;
1632	struct TCP_Server_Info *server;
1633	struct cifs_fid fid;
1634	struct cifs_open_parms oparms;
1635	int oplock, rc;
1636
1637	tlink = cifs_sb_tlink(cifs_sb);
1638	if (IS_ERR(tlink))
1639		return PTR_ERR(tlink);
1640	tcon = tlink_tcon(tlink);
1641	server = tcon->ses->server;
1642
1643	if (!server->ops->rename)
1644		return -ENOSYS;
1645
1646	/* try path-based rename first */
1647	rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1648
1649	/*
1650	 * Don't bother with rename by filehandle unless file is busy and
1651	 * source. Note that cross directory moves do not work with
1652	 * rename by filehandle to various Windows servers.
1653	 */
1654	if (rc == 0 || rc != -EBUSY)
1655		goto do_rename_exit;
1656
 
 
 
 
1657	/* open-file renames don't work across directories */
1658	if (to_dentry->d_parent != from_dentry->d_parent)
1659		goto do_rename_exit;
1660
1661	oparms.tcon = tcon;
1662	oparms.cifs_sb = cifs_sb;
1663	/* open the file to be renamed -- we need DELETE perms */
1664	oparms.desired_access = DELETE;
1665	oparms.create_options = CREATE_NOT_DIR;
1666	oparms.disposition = FILE_OPEN;
1667	oparms.path = from_path;
1668	oparms.fid = &fid;
1669	oparms.reconnect = false;
1670
1671	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1672	if (rc == 0) {
1673		rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1674				(const char *) to_dentry->d_name.name,
1675				cifs_sb->local_nls, cifs_remap(cifs_sb));
1676		CIFSSMBClose(xid, tcon, fid.netfid);
1677	}
1678do_rename_exit:
 
 
1679	cifs_put_tlink(tlink);
1680	return rc;
1681}
1682
1683int
1684cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1685	     struct inode *target_dir, struct dentry *target_dentry,
1686	     unsigned int flags)
1687{
1688	char *from_name = NULL;
1689	char *to_name = NULL;
1690	struct cifs_sb_info *cifs_sb;
1691	struct tcon_link *tlink;
1692	struct cifs_tcon *tcon;
1693	FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1694	FILE_UNIX_BASIC_INFO *info_buf_target;
1695	unsigned int xid;
1696	int rc, tmprc;
1697
1698	if (flags & ~RENAME_NOREPLACE)
1699		return -EINVAL;
1700
1701	cifs_sb = CIFS_SB(source_dir->i_sb);
1702	tlink = cifs_sb_tlink(cifs_sb);
1703	if (IS_ERR(tlink))
1704		return PTR_ERR(tlink);
1705	tcon = tlink_tcon(tlink);
1706
1707	xid = get_xid();
1708
1709	/*
1710	 * we already have the rename sem so we do not need to
1711	 * grab it again here to protect the path integrity
1712	 */
1713	from_name = build_path_from_dentry(source_dentry);
1714	if (from_name == NULL) {
1715		rc = -ENOMEM;
1716		goto cifs_rename_exit;
1717	}
1718
1719	to_name = build_path_from_dentry(target_dentry);
1720	if (to_name == NULL) {
1721		rc = -ENOMEM;
1722		goto cifs_rename_exit;
1723	}
1724
1725	rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1726			    to_name);
1727
1728	/*
1729	 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1730	 */
1731	if (flags & RENAME_NOREPLACE)
1732		goto cifs_rename_exit;
1733
1734	if (rc == -EEXIST && tcon->unix_ext) {
1735		/*
1736		 * Are src and dst hardlinks of same inode? We can only tell
1737		 * with unix extensions enabled.
1738		 */
1739		info_buf_source =
1740			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1741					GFP_KERNEL);
1742		if (info_buf_source == NULL) {
1743			rc = -ENOMEM;
1744			goto cifs_rename_exit;
1745		}
1746
1747		info_buf_target = info_buf_source + 1;
1748		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1749					     info_buf_source,
1750					     cifs_sb->local_nls,
1751					     cifs_remap(cifs_sb));
1752		if (tmprc != 0)
1753			goto unlink_target;
1754
1755		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1756					     info_buf_target,
1757					     cifs_sb->local_nls,
1758					     cifs_remap(cifs_sb));
1759
1760		if (tmprc == 0 && (info_buf_source->UniqueId ==
1761				   info_buf_target->UniqueId)) {
1762			/* same file, POSIX says that this is a noop */
1763			rc = 0;
1764			goto cifs_rename_exit;
1765		}
1766	}
1767	/*
1768	 * else ... BB we could add the same check for Windows by
1769	 * checking the UniqueId via FILE_INTERNAL_INFO
1770	 */
1771
1772unlink_target:
1773	/* Try unlinking the target dentry if it's not negative */
1774	if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1775		if (d_is_dir(target_dentry))
1776			tmprc = cifs_rmdir(target_dir, target_dentry);
1777		else
1778			tmprc = cifs_unlink(target_dir, target_dentry);
1779		if (tmprc)
1780			goto cifs_rename_exit;
1781		rc = cifs_do_rename(xid, source_dentry, from_name,
1782				    target_dentry, to_name);
1783	}
1784
1785	/* force revalidate to go get info when needed */
1786	CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1787
1788	source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1789		target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1790
1791cifs_rename_exit:
1792	kfree(info_buf_source);
1793	kfree(from_name);
1794	kfree(to_name);
1795	free_xid(xid);
1796	cifs_put_tlink(tlink);
1797	return rc;
1798}
1799
1800static bool
1801cifs_inode_needs_reval(struct inode *inode)
1802{
1803	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1804	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1805
 
 
 
1806	if (CIFS_CACHE_READ(cifs_i))
1807		return false;
1808
1809	if (!lookupCacheEnabled)
1810		return true;
1811
1812	if (cifs_i->time == 0)
1813		return true;
1814
1815	if (!cifs_sb->actimeo)
1816		return true;
1817
1818	if (!time_in_range(jiffies, cifs_i->time,
1819				cifs_i->time + cifs_sb->actimeo))
1820		return true;
1821
1822	/* hardlinked files w/ noserverino get "special" treatment */
1823	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1824	    S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1825		return true;
1826
1827	return false;
1828}
1829
1830/*
1831 * Zap the cache. Called when invalid_mapping flag is set.
1832 */
1833int
1834cifs_invalidate_mapping(struct inode *inode)
1835{
1836	int rc = 0;
1837
1838	if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1839		rc = invalidate_inode_pages2(inode->i_mapping);
1840		if (rc)
1841			cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1842				 __func__, inode);
1843	}
1844
1845	cifs_fscache_reset_inode_cookie(inode);
1846	return rc;
1847}
1848
1849/**
1850 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1851 * @word: long word containing the bit lock
1852 */
1853static int
1854cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1855{
1856	freezable_schedule_unsafe();
1857	if (signal_pending_state(mode, current))
1858		return -ERESTARTSYS;
1859	return 0;
1860}
1861
1862int
1863cifs_revalidate_mapping(struct inode *inode)
1864{
1865	int rc;
1866	unsigned long *flags = &CIFS_I(inode)->flags;
1867
 
 
 
 
1868	rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1869				     TASK_KILLABLE);
1870	if (rc)
1871		return rc;
1872
1873	if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1874		rc = cifs_invalidate_mapping(inode);
1875		if (rc)
1876			set_bit(CIFS_INO_INVALID_MAPPING, flags);
1877	}
1878
1879	clear_bit_unlock(CIFS_INO_LOCK, flags);
1880	smp_mb__after_atomic();
1881	wake_up_bit(flags, CIFS_INO_LOCK);
1882
1883	return rc;
1884}
1885
1886int
1887cifs_zap_mapping(struct inode *inode)
1888{
1889	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1890	return cifs_revalidate_mapping(inode);
1891}
1892
1893int cifs_revalidate_file_attr(struct file *filp)
1894{
1895	int rc = 0;
1896	struct inode *inode = file_inode(filp);
1897	struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1898
1899	if (!cifs_inode_needs_reval(inode))
1900		return rc;
1901
1902	if (tlink_tcon(cfile->tlink)->unix_ext)
1903		rc = cifs_get_file_info_unix(filp);
1904	else
1905		rc = cifs_get_file_info(filp);
1906
1907	return rc;
1908}
1909
1910int cifs_revalidate_dentry_attr(struct dentry *dentry)
1911{
1912	unsigned int xid;
1913	int rc = 0;
1914	struct inode *inode = d_inode(dentry);
1915	struct super_block *sb = dentry->d_sb;
1916	char *full_path = NULL;
 
1917
1918	if (inode == NULL)
1919		return -ENOENT;
1920
1921	if (!cifs_inode_needs_reval(inode))
1922		return rc;
1923
1924	xid = get_xid();
1925
1926	/* can not safely grab the rename sem here if rename calls revalidate
1927	   since that would deadlock */
1928	full_path = build_path_from_dentry(dentry);
1929	if (full_path == NULL) {
1930		rc = -ENOMEM;
1931		goto out;
1932	}
1933
1934	cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1935		 full_path, inode, inode->i_count.counter,
1936		 dentry, dentry->d_time, jiffies);
1937
1938	if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
 
 
 
1939		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1940	else
1941		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1942					 xid, NULL);
1943
 
1944out:
1945	kfree(full_path);
1946	free_xid(xid);
 
1947	return rc;
1948}
1949
1950int cifs_revalidate_file(struct file *filp)
1951{
1952	int rc;
1953	struct inode *inode = file_inode(filp);
1954
1955	rc = cifs_revalidate_file_attr(filp);
1956	if (rc)
1957		return rc;
1958
1959	return cifs_revalidate_mapping(inode);
1960}
1961
1962/* revalidate a dentry's inode attributes */
1963int cifs_revalidate_dentry(struct dentry *dentry)
1964{
1965	int rc;
1966	struct inode *inode = d_inode(dentry);
1967
1968	rc = cifs_revalidate_dentry_attr(dentry);
1969	if (rc)
1970		return rc;
1971
1972	return cifs_revalidate_mapping(inode);
1973}
1974
1975int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1976		 struct kstat *stat)
1977{
 
1978	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1979	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1980	struct inode *inode = d_inode(dentry);
1981	int rc;
1982
1983	/*
1984	 * We need to be sure that all dirty pages are written and the server
1985	 * has actual ctime, mtime and file length.
1986	 */
1987	if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1988	    inode->i_mapping->nrpages != 0) {
 
1989		rc = filemap_fdatawait(inode->i_mapping);
1990		if (rc) {
1991			mapping_set_error(inode->i_mapping, rc);
1992			return rc;
1993		}
1994	}
1995
1996	rc = cifs_revalidate_dentry_attr(dentry);
1997	if (rc)
1998		return rc;
 
 
 
 
 
 
 
 
 
 
 
1999
2000	generic_fillattr(inode, stat);
2001	stat->blksize = CIFS_MAX_MSGSIZE;
2002	stat->ino = CIFS_I(inode)->uniqueid;
2003
 
 
 
 
 
 
 
 
 
 
 
 
 
2004	/*
2005	 * If on a multiuser mount without unix extensions or cifsacl being
2006	 * enabled, and the admin hasn't overridden them, set the ownership
2007	 * to the fsuid/fsgid of the current process.
2008	 */
2009	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2010	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2011	    !tcon->unix_ext) {
2012		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2013			stat->uid = current_fsuid();
2014		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2015			stat->gid = current_fsgid();
2016	}
2017	return rc;
2018}
2019
2020static int cifs_truncate_page(struct address_space *mapping, loff_t from)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2021{
2022	pgoff_t index = from >> PAGE_SHIFT;
2023	unsigned offset = from & (PAGE_SIZE - 1);
2024	struct page *page;
2025	int rc = 0;
2026
2027	page = grab_cache_page(mapping, index);
2028	if (!page)
2029		return -ENOMEM;
2030
2031	zero_user_segment(page, offset, PAGE_SIZE);
2032	unlock_page(page);
2033	put_page(page);
2034	return rc;
2035}
2036
2037static void cifs_setsize(struct inode *inode, loff_t offset)
2038{
 
 
2039	spin_lock(&inode->i_lock);
2040	i_size_write(inode, offset);
2041	spin_unlock(&inode->i_lock);
2042
 
 
2043	truncate_pagecache(inode, offset);
2044}
2045
2046static int
2047cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2048		   unsigned int xid, char *full_path)
2049{
2050	int rc;
2051	struct cifsFileInfo *open_file;
2052	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2053	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2054	struct tcon_link *tlink = NULL;
2055	struct cifs_tcon *tcon = NULL;
2056	struct TCP_Server_Info *server;
2057
2058	/*
2059	 * To avoid spurious oplock breaks from server, in the case of
2060	 * inodes that we already have open, avoid doing path based
2061	 * setting of file size if we can do it by handle.
2062	 * This keeps our caching token (oplock) and avoids timeouts
2063	 * when the local oplock break takes longer to flush
2064	 * writebehind data than the SMB timeout for the SetPathInfo
2065	 * request would allow
2066	 */
2067	open_file = find_writable_file(cifsInode, true);
2068	if (open_file) {
2069		tcon = tlink_tcon(open_file->tlink);
2070		server = tcon->ses->server;
2071		if (server->ops->set_file_size)
2072			rc = server->ops->set_file_size(xid, tcon, open_file,
2073							attrs->ia_size, false);
2074		else
2075			rc = -ENOSYS;
2076		cifsFileInfo_put(open_file);
2077		cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2078	} else
2079		rc = -EINVAL;
2080
2081	if (!rc)
2082		goto set_size_out;
2083
2084	if (tcon == NULL) {
2085		tlink = cifs_sb_tlink(cifs_sb);
2086		if (IS_ERR(tlink))
2087			return PTR_ERR(tlink);
2088		tcon = tlink_tcon(tlink);
2089		server = tcon->ses->server;
2090	}
2091
2092	/*
2093	 * Set file size by pathname rather than by handle either because no
2094	 * valid, writeable file handle for it was found or because there was
2095	 * an error setting it by handle.
2096	 */
2097	if (server->ops->set_path_size)
2098		rc = server->ops->set_path_size(xid, tcon, full_path,
2099						attrs->ia_size, cifs_sb, false);
2100	else
2101		rc = -ENOSYS;
2102	cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2103
2104	if (tlink)
2105		cifs_put_tlink(tlink);
2106
2107set_size_out:
2108	if (rc == 0) {
2109		cifsInode->server_eof = attrs->ia_size;
2110		cifs_setsize(inode, attrs->ia_size);
 
 
 
 
 
 
 
 
 
2111		cifs_truncate_page(inode->i_mapping, inode->i_size);
2112	}
2113
2114	return rc;
2115}
2116
2117static int
2118cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2119{
2120	int rc;
2121	unsigned int xid;
2122	char *full_path = NULL;
2123	struct inode *inode = d_inode(direntry);
2124	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2125	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2126	struct tcon_link *tlink;
2127	struct cifs_tcon *pTcon;
2128	struct cifs_unix_set_info_args *args = NULL;
2129	struct cifsFileInfo *open_file;
2130
2131	cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2132		 direntry, attrs->ia_valid);
2133
2134	xid = get_xid();
2135
2136	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2137		attrs->ia_valid |= ATTR_FORCE;
2138
2139	rc = inode_change_ok(inode, attrs);
2140	if (rc < 0)
2141		goto out;
2142
2143	full_path = build_path_from_dentry(direntry);
2144	if (full_path == NULL) {
2145		rc = -ENOMEM;
2146		goto out;
2147	}
2148
2149	/*
2150	 * Attempt to flush data before changing attributes. We need to do
2151	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2152	 * ownership or mode then we may also need to do this. Here, we take
2153	 * the safe way out and just do the flush on all setattr requests. If
2154	 * the flush returns error, store it to report later and continue.
2155	 *
2156	 * BB: This should be smarter. Why bother flushing pages that
2157	 * will be truncated anyway? Also, should we error out here if
2158	 * the flush returns error?
2159	 */
2160	rc = filemap_write_and_wait(inode->i_mapping);
 
 
 
 
 
2161	mapping_set_error(inode->i_mapping, rc);
2162	rc = 0;
2163
2164	if (attrs->ia_valid & ATTR_SIZE) {
2165		rc = cifs_set_file_size(inode, attrs, xid, full_path);
2166		if (rc != 0)
2167			goto out;
2168	}
2169
2170	/* skip mode change if it's just for clearing setuid/setgid */
2171	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2172		attrs->ia_valid &= ~ATTR_MODE;
2173
2174	args = kmalloc(sizeof(*args), GFP_KERNEL);
2175	if (args == NULL) {
2176		rc = -ENOMEM;
2177		goto out;
2178	}
2179
2180	/* set up the struct */
2181	if (attrs->ia_valid & ATTR_MODE)
2182		args->mode = attrs->ia_mode;
2183	else
2184		args->mode = NO_CHANGE_64;
2185
2186	if (attrs->ia_valid & ATTR_UID)
2187		args->uid = attrs->ia_uid;
2188	else
2189		args->uid = INVALID_UID; /* no change */
2190
2191	if (attrs->ia_valid & ATTR_GID)
2192		args->gid = attrs->ia_gid;
2193	else
2194		args->gid = INVALID_GID; /* no change */
2195
2196	if (attrs->ia_valid & ATTR_ATIME)
2197		args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2198	else
2199		args->atime = NO_CHANGE_64;
2200
2201	if (attrs->ia_valid & ATTR_MTIME)
2202		args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2203	else
2204		args->mtime = NO_CHANGE_64;
2205
2206	if (attrs->ia_valid & ATTR_CTIME)
2207		args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2208	else
2209		args->ctime = NO_CHANGE_64;
2210
2211	args->device = 0;
2212	open_file = find_writable_file(cifsInode, true);
2213	if (open_file) {
2214		u16 nfid = open_file->fid.netfid;
2215		u32 npid = open_file->pid;
2216		pTcon = tlink_tcon(open_file->tlink);
2217		rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2218		cifsFileInfo_put(open_file);
2219	} else {
2220		tlink = cifs_sb_tlink(cifs_sb);
2221		if (IS_ERR(tlink)) {
2222			rc = PTR_ERR(tlink);
2223			goto out;
2224		}
2225		pTcon = tlink_tcon(tlink);
2226		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2227				    cifs_sb->local_nls,
2228				    cifs_remap(cifs_sb));
2229		cifs_put_tlink(tlink);
2230	}
2231
2232	if (rc)
2233		goto out;
2234
2235	if ((attrs->ia_valid & ATTR_SIZE) &&
2236	    attrs->ia_size != i_size_read(inode))
2237		truncate_setsize(inode, attrs->ia_size);
2238
2239	setattr_copy(inode, attrs);
2240	mark_inode_dirty(inode);
2241
2242	/* force revalidate when any of these times are set since some
2243	   of the fs types (eg ext3, fat) do not have fine enough
2244	   time granularity to match protocol, and we do not have a
2245	   a way (yet) to query the server fs's time granularity (and
2246	   whether it rounds times down).
2247	*/
2248	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2249		cifsInode->time = 0;
2250out:
2251	kfree(args);
2252	kfree(full_path);
2253	free_xid(xid);
2254	return rc;
2255}
2256
2257static int
2258cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2259{
2260	unsigned int xid;
2261	kuid_t uid = INVALID_UID;
2262	kgid_t gid = INVALID_GID;
2263	struct inode *inode = d_inode(direntry);
2264	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2265	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
 
 
2266	char *full_path = NULL;
2267	int rc = -EACCES;
2268	__u32 dosattr = 0;
2269	__u64 mode = NO_CHANGE_64;
2270
2271	xid = get_xid();
2272
2273	cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2274		 direntry, attrs->ia_valid);
2275
2276	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2277		attrs->ia_valid |= ATTR_FORCE;
2278
2279	rc = inode_change_ok(inode, attrs);
2280	if (rc < 0) {
2281		free_xid(xid);
2282		return rc;
2283	}
2284
2285	full_path = build_path_from_dentry(direntry);
2286	if (full_path == NULL) {
2287		rc = -ENOMEM;
2288		free_xid(xid);
2289		return rc;
2290	}
2291
2292	/*
2293	 * Attempt to flush data before changing attributes. We need to do
2294	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2295	 * ownership or mode then we may also need to do this. Here, we take
2296	 * the safe way out and just do the flush on all setattr requests. If
2297	 * the flush returns error, store it to report later and continue.
2298	 *
2299	 * BB: This should be smarter. Why bother flushing pages that
2300	 * will be truncated anyway? Also, should we error out here if
2301	 * the flush returns error?
2302	 */
2303	rc = filemap_write_and_wait(inode->i_mapping);
2304	mapping_set_error(inode->i_mapping, rc);
 
 
 
 
 
 
 
2305	rc = 0;
2306
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2307	if (attrs->ia_valid & ATTR_SIZE) {
2308		rc = cifs_set_file_size(inode, attrs, xid, full_path);
2309		if (rc != 0)
2310			goto cifs_setattr_exit;
2311	}
2312
2313	if (attrs->ia_valid & ATTR_UID)
2314		uid = attrs->ia_uid;
2315
2316	if (attrs->ia_valid & ATTR_GID)
2317		gid = attrs->ia_gid;
2318
2319#ifdef CONFIG_CIFS_ACL
2320	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2321		if (uid_valid(uid) || gid_valid(gid)) {
2322			rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2323							uid, gid);
2324			if (rc) {
2325				cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2326					 __func__, rc);
2327				goto cifs_setattr_exit;
2328			}
2329		}
2330	} else
2331#endif /* CONFIG_CIFS_ACL */
2332	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2333		attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2334
2335	/* skip mode change if it's just for clearing setuid/setgid */
2336	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2337		attrs->ia_valid &= ~ATTR_MODE;
2338
2339	if (attrs->ia_valid & ATTR_MODE) {
2340		mode = attrs->ia_mode;
2341		rc = 0;
2342#ifdef CONFIG_CIFS_ACL
2343		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2344			rc = id_mode_to_cifs_acl(inode, full_path, mode,
2345						INVALID_UID, INVALID_GID);
2346			if (rc) {
2347				cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2348					 __func__, rc);
2349				goto cifs_setattr_exit;
2350			}
2351		} else
2352#endif /* CONFIG_CIFS_ACL */
2353		if (((mode & S_IWUGO) == 0) &&
2354		    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2355
2356			dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2357
2358			/* fix up mode if we're not using dynperm */
2359			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2360				attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2361		} else if ((mode & S_IWUGO) &&
2362			   (cifsInode->cifsAttrs & ATTR_READONLY)) {
2363
2364			dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2365			/* Attributes of 0 are ignored */
2366			if (dosattr == 0)
2367				dosattr |= ATTR_NORMAL;
2368
2369			/* reset local inode permissions to normal */
2370			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2371				attrs->ia_mode &= ~(S_IALLUGO);
2372				if (S_ISDIR(inode->i_mode))
2373					attrs->ia_mode |=
2374						cifs_sb->mnt_dir_mode;
2375				else
2376					attrs->ia_mode |=
2377						cifs_sb->mnt_file_mode;
2378			}
2379		} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2380			/* ignore mode change - ATTR_READONLY hasn't changed */
2381			attrs->ia_valid &= ~ATTR_MODE;
2382		}
2383	}
2384
2385	if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2386	    ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2387		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2388		/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2389
2390		/* Even if error on time set, no sense failing the call if
2391		the server would set the time to a reasonable value anyway,
2392		and this check ensures that we are not being called from
2393		sys_utimes in which case we ought to fail the call back to
2394		the user when the server rejects the call */
2395		if ((rc) && (attrs->ia_valid &
2396				(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2397			rc = 0;
2398	}
2399
2400	/* do not need local check to inode_check_ok since the server does
2401	   that */
2402	if (rc)
2403		goto cifs_setattr_exit;
2404
2405	if ((attrs->ia_valid & ATTR_SIZE) &&
2406	    attrs->ia_size != i_size_read(inode))
2407		truncate_setsize(inode, attrs->ia_size);
2408
2409	setattr_copy(inode, attrs);
2410	mark_inode_dirty(inode);
2411
2412cifs_setattr_exit:
2413	kfree(full_path);
2414	free_xid(xid);
2415	return rc;
2416}
2417
2418int
2419cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2420{
2421	struct inode *inode = d_inode(direntry);
2422	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2423	struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2424
2425	if (pTcon->unix_ext)
2426		return cifs_setattr_unix(direntry, attrs);
2427
2428	return cifs_setattr_nounix(direntry, attrs);
2429
2430	/* BB: add cifs_setattr_legacy for really old servers */
2431}
2432
2433#if 0
2434void cifs_delete_inode(struct inode *inode)
2435{
2436	cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2437	/* may have to add back in if and when safe distributed caching of
2438	   directories added e.g. via FindNotify */
2439}
2440#endif