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	char *path = NULL;
1006	int len;
1007
1008	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1009	    && cifs_sb->prepath) {
1010		len = strlen(cifs_sb->prepath);
1011		path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1012		if (path == NULL)
1013			return ERR_PTR(-ENOMEM);
1014		path[0] = '/';
1015		memcpy(path+1, cifs_sb->prepath, len);
1016	} else {
1017		path = kstrdup("", GFP_KERNEL);
1018		if (path == NULL)
1019			return ERR_PTR(-ENOMEM);
1020	}
1021
1022	xid = get_xid();
1023	if (tcon->unix_ext) {
1024		rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1025		/* some servers mistakenly claim POSIX support */
1026		if (rc != -EOPNOTSUPP)
1027			goto iget_no_retry;
1028		cifs_dbg(VFS, "server does not support POSIX extensions");
1029		tcon->unix_ext = false;
1030	}
1031
1032	convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1033	rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1034
1035iget_no_retry:
1036	if (!inode) {
1037		inode = ERR_PTR(rc);
1038		goto out;
1039	}
1040
1041#ifdef CONFIG_CIFS_FSCACHE
1042	/* populate tcon->resource_id */
1043	tcon->resource_id = CIFS_I(inode)->uniqueid;
1044#endif
1045
1046	if (rc && tcon->ipc) {
1047		cifs_dbg(FYI, "ipc connection - fake read inode\n");
1048		spin_lock(&inode->i_lock);
1049		inode->i_mode |= S_IFDIR;
1050		set_nlink(inode, 2);
1051		inode->i_op = &cifs_ipc_inode_ops;
1052		inode->i_fop = &simple_dir_operations;
1053		inode->i_uid = cifs_sb->mnt_uid;
1054		inode->i_gid = cifs_sb->mnt_gid;
1055		spin_unlock(&inode->i_lock);
1056	} else if (rc) {
1057		iget_failed(inode);
1058		inode = ERR_PTR(rc);
1059	}
1060
1061out:
1062	kfree(path);
1063	/* can not call macro free_xid here since in a void func
1064	 * TODO: This is no longer true
1065	 */
1066	_free_xid(xid);
1067	return inode;
1068}
1069
1070int
1071cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1072		   char *full_path, __u32 dosattr)
1073{
1074	bool set_time = false;
1075	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1076	struct TCP_Server_Info *server;
1077	FILE_BASIC_INFO	info_buf;
1078
1079	if (attrs == NULL)
1080		return -EINVAL;
1081
1082	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1083	if (!server->ops->set_file_info)
1084		return -ENOSYS;
1085
 
 
1086	if (attrs->ia_valid & ATTR_ATIME) {
1087		set_time = true;
1088		info_buf.LastAccessTime =
1089			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1090	} else
1091		info_buf.LastAccessTime = 0;
1092
1093	if (attrs->ia_valid & ATTR_MTIME) {
1094		set_time = true;
1095		info_buf.LastWriteTime =
1096		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1097	} else
1098		info_buf.LastWriteTime = 0;
1099
1100	/*
1101	 * Samba throws this field away, but windows may actually use it.
1102	 * Do not set ctime unless other time stamps are changed explicitly
1103	 * (i.e. by utimes()) since we would then have a mix of client and
1104	 * server times.
1105	 */
1106	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1107		cifs_dbg(FYI, "CIFS - CTIME changed\n");
1108		info_buf.ChangeTime =
1109		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1110	} else
1111		info_buf.ChangeTime = 0;
1112
1113	info_buf.CreationTime = 0;	/* don't change */
1114	info_buf.Attributes = cpu_to_le32(dosattr);
1115
1116	return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1117}
1118
1119/*
1120 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1121 * and rename it to a random name that hopefully won't conflict with
1122 * anything else.
1123 */
1124int
1125cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1126			   const unsigned int xid)
1127{
1128	int oplock = 0;
1129	int rc;
1130	struct cifs_fid fid;
1131	struct cifs_open_parms oparms;
1132	struct inode *inode = d_inode(dentry);
1133	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1134	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1135	struct tcon_link *tlink;
1136	struct cifs_tcon *tcon;
1137	__u32 dosattr, origattr;
1138	FILE_BASIC_INFO *info_buf = NULL;
1139
1140	tlink = cifs_sb_tlink(cifs_sb);
1141	if (IS_ERR(tlink))
1142		return PTR_ERR(tlink);
1143	tcon = tlink_tcon(tlink);
1144
1145	/*
1146	 * We cannot rename the file if the server doesn't support
1147	 * CAP_INFOLEVEL_PASSTHRU
1148	 */
1149	if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1150		rc = -EBUSY;
1151		goto out;
1152	}
1153
1154	oparms.tcon = tcon;
1155	oparms.cifs_sb = cifs_sb;
1156	oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1157	oparms.create_options = CREATE_NOT_DIR;
1158	oparms.disposition = FILE_OPEN;
1159	oparms.path = full_path;
1160	oparms.fid = &fid;
1161	oparms.reconnect = false;
1162
1163	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1164	if (rc != 0)
1165		goto out;
1166
1167	origattr = cifsInode->cifsAttrs;
1168	if (origattr == 0)
1169		origattr |= ATTR_NORMAL;
1170
1171	dosattr = origattr & ~ATTR_READONLY;
1172	if (dosattr == 0)
1173		dosattr |= ATTR_NORMAL;
1174	dosattr |= ATTR_HIDDEN;
1175
1176	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1177	if (dosattr != origattr) {
1178		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1179		if (info_buf == NULL) {
1180			rc = -ENOMEM;
1181			goto out_close;
1182		}
1183		info_buf->Attributes = cpu_to_le32(dosattr);
1184		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1185					current->tgid);
1186		/* although we would like to mark the file hidden
1187 		   if that fails we will still try to rename it */
1188		if (!rc)
1189			cifsInode->cifsAttrs = dosattr;
1190		else
1191			dosattr = origattr; /* since not able to change them */
1192	}
1193
1194	/* rename the file */
1195	rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1196				   cifs_sb->local_nls,
1197				   cifs_remap(cifs_sb));
1198	if (rc != 0) {
1199		rc = -EBUSY;
1200		goto undo_setattr;
1201	}
1202
1203	/* try to set DELETE_ON_CLOSE */
1204	if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1205		rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1206					       current->tgid);
1207		/*
1208		 * some samba versions return -ENOENT when we try to set the
1209		 * file disposition here. Likely a samba bug, but work around
1210		 * it for now. This means that some cifsXXX files may hang
1211		 * around after they shouldn't.
1212		 *
1213		 * BB: remove this hack after more servers have the fix
1214		 */
1215		if (rc == -ENOENT)
1216			rc = 0;
1217		else if (rc != 0) {
1218			rc = -EBUSY;
1219			goto undo_rename;
1220		}
1221		set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1222	}
1223
1224out_close:
1225	CIFSSMBClose(xid, tcon, fid.netfid);
1226out:
1227	kfree(info_buf);
1228	cifs_put_tlink(tlink);
1229	return rc;
1230
1231	/*
1232	 * reset everything back to the original state. Don't bother
1233	 * dealing with errors here since we can't do anything about
1234	 * them anyway.
1235	 */
1236undo_rename:
1237	CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1238				cifs_sb->local_nls, cifs_remap(cifs_sb));
1239undo_setattr:
1240	if (dosattr != origattr) {
1241		info_buf->Attributes = cpu_to_le32(origattr);
1242		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1243					current->tgid))
1244			cifsInode->cifsAttrs = origattr;
1245	}
1246
1247	goto out_close;
1248}
1249
1250/* copied from fs/nfs/dir.c with small changes */
1251static void
1252cifs_drop_nlink(struct inode *inode)
1253{
1254	spin_lock(&inode->i_lock);
1255	if (inode->i_nlink > 0)
1256		drop_nlink(inode);
1257	spin_unlock(&inode->i_lock);
1258}
1259
1260/*
1261 * If d_inode(dentry) is null (usually meaning the cached dentry
1262 * is a negative dentry) then we would attempt a standard SMB delete, but
1263 * if that fails we can not attempt the fall back mechanisms on EACCESS
1264 * but will return the EACCESS to the caller. Note that the VFS does not call
1265 * unlink on negative dentries currently.
1266 */
1267int cifs_unlink(struct inode *dir, struct dentry *dentry)
1268{
1269	int rc = 0;
1270	unsigned int xid;
1271	char *full_path = NULL;
1272	struct inode *inode = d_inode(dentry);
1273	struct cifsInodeInfo *cifs_inode;
1274	struct super_block *sb = dir->i_sb;
1275	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1276	struct tcon_link *tlink;
1277	struct cifs_tcon *tcon;
1278	struct TCP_Server_Info *server;
1279	struct iattr *attrs = NULL;
1280	__u32 dosattr = 0, origattr = 0;
1281
1282	cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1283
1284	tlink = cifs_sb_tlink(cifs_sb);
1285	if (IS_ERR(tlink))
1286		return PTR_ERR(tlink);
1287	tcon = tlink_tcon(tlink);
1288	server = tcon->ses->server;
1289
1290	xid = get_xid();
1291
1292	/* Unlink can be called from rename so we can not take the
1293	 * sb->s_vfs_rename_mutex here */
1294	full_path = build_path_from_dentry(dentry);
1295	if (full_path == NULL) {
1296		rc = -ENOMEM;
1297		goto unlink_out;
1298	}
1299
1300	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1301				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1302		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1303			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1304			cifs_remap(cifs_sb));
1305		cifs_dbg(FYI, "posix del rc %d\n", rc);
1306		if ((rc == 0) || (rc == -ENOENT))
1307			goto psx_del_no_retry;
1308	}
1309
1310retry_std_delete:
1311	if (!server->ops->unlink) {
1312		rc = -ENOSYS;
1313		goto psx_del_no_retry;
1314	}
1315
1316	rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1317
1318psx_del_no_retry:
1319	if (!rc) {
1320		if (inode)
1321			cifs_drop_nlink(inode);
1322	} else if (rc == -ENOENT) {
1323		d_drop(dentry);
1324	} else if (rc == -EBUSY) {
1325		if (server->ops->rename_pending_delete) {
1326			rc = server->ops->rename_pending_delete(full_path,
1327								dentry, xid);
1328			if (rc == 0)
1329				cifs_drop_nlink(inode);
1330		}
1331	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1332		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1333		if (attrs == NULL) {
1334			rc = -ENOMEM;
1335			goto out_reval;
1336		}
1337
1338		/* try to reset dos attributes */
1339		cifs_inode = CIFS_I(inode);
1340		origattr = cifs_inode->cifsAttrs;
1341		if (origattr == 0)
1342			origattr |= ATTR_NORMAL;
1343		dosattr = origattr & ~ATTR_READONLY;
1344		if (dosattr == 0)
1345			dosattr |= ATTR_NORMAL;
1346		dosattr |= ATTR_HIDDEN;
1347
1348		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1349		if (rc != 0)
1350			goto out_reval;
1351
1352		goto retry_std_delete;
1353	}
1354
1355	/* undo the setattr if we errored out and it's needed */
1356	if (rc != 0 && dosattr != 0)
1357		cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1358
1359out_reval:
1360	if (inode) {
1361		cifs_inode = CIFS_I(inode);
1362		cifs_inode->time = 0;	/* will force revalidate to get info
1363					   when needed */
1364		inode->i_ctime = current_fs_time(sb);
1365	}
1366	dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1367	cifs_inode = CIFS_I(dir);
1368	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */
1369unlink_out:
1370	kfree(full_path);
1371	kfree(attrs);
1372	free_xid(xid);
1373	cifs_put_tlink(tlink);
1374	return rc;
1375}
1376
1377static int
1378cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1379		 const char *full_path, struct cifs_sb_info *cifs_sb,
1380		 struct cifs_tcon *tcon, const unsigned int xid)
1381{
1382	int rc = 0;
1383	struct inode *inode = NULL;
1384
1385	if (tcon->unix_ext)
1386		rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1387					      xid);
1388	else
1389		rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1390					 xid, NULL);
1391
1392	if (rc)
1393		return rc;
1394
1395	/*
1396	 * setting nlink not necessary except in cases where we failed to get it
1397	 * from the server or was set bogus. Also, since this is a brand new
1398	 * inode, no need to grab the i_lock before setting the i_nlink.
1399	 */
1400	if (inode->i_nlink < 2)
1401		set_nlink(inode, 2);
1402	mode &= ~current_umask();
1403	/* must turn on setgid bit if parent dir has it */
1404	if (parent->i_mode & S_ISGID)
1405		mode |= S_ISGID;
1406
1407	if (tcon->unix_ext) {
1408		struct cifs_unix_set_info_args args = {
1409			.mode	= mode,
1410			.ctime	= NO_CHANGE_64,
1411			.atime	= NO_CHANGE_64,
1412			.mtime	= NO_CHANGE_64,
1413			.device	= 0,
1414		};
1415		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1416			args.uid = current_fsuid();
1417			if (parent->i_mode & S_ISGID)
1418				args.gid = parent->i_gid;
1419			else
1420				args.gid = current_fsgid();
1421		} else {
1422			args.uid = INVALID_UID; /* no change */
1423			args.gid = INVALID_GID; /* no change */
1424		}
1425		CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1426				       cifs_sb->local_nls,
1427				       cifs_remap(cifs_sb));
1428	} else {
1429		struct TCP_Server_Info *server = tcon->ses->server;
1430		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1431		    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1432			server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1433						   tcon, xid);
1434		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1435			inode->i_mode = (mode | S_IFDIR);
1436
1437		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1438			inode->i_uid = current_fsuid();
1439			if (inode->i_mode & S_ISGID)
1440				inode->i_gid = parent->i_gid;
1441			else
1442				inode->i_gid = current_fsgid();
1443		}
1444	}
1445	d_instantiate(dentry, inode);
1446	return rc;
1447}
1448
1449static int
1450cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1451		 const char *full_path, struct cifs_sb_info *cifs_sb,
1452		 struct cifs_tcon *tcon, const unsigned int xid)
1453{
1454	int rc = 0;
1455	u32 oplock = 0;
1456	FILE_UNIX_BASIC_INFO *info = NULL;
1457	struct inode *newinode = NULL;
1458	struct cifs_fattr fattr;
1459
1460	info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1461	if (info == NULL) {
1462		rc = -ENOMEM;
1463		goto posix_mkdir_out;
1464	}
1465
1466	mode &= ~current_umask();
1467	rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1468			     NULL /* netfid */, info, &oplock, full_path,
1469			     cifs_sb->local_nls, cifs_remap(cifs_sb));
1470	if (rc == -EOPNOTSUPP)
1471		goto posix_mkdir_out;
1472	else if (rc) {
1473		cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1474		d_drop(dentry);
1475		goto posix_mkdir_out;
1476	}
1477
1478	if (info->Type == cpu_to_le32(-1))
1479		/* no return info, go query for it */
1480		goto posix_mkdir_get_info;
1481	/*
1482	 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1483	 * need to set uid/gid.
1484	 */
1485
1486	cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1487	cifs_fill_uniqueid(inode->i_sb, &fattr);
1488	newinode = cifs_iget(inode->i_sb, &fattr);
1489	if (!newinode)
1490		goto posix_mkdir_get_info;
1491
1492	d_instantiate(dentry, newinode);
1493
1494#ifdef CONFIG_CIFS_DEBUG2
1495	cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1496		 dentry, dentry, newinode);
1497
1498	if (newinode->i_nlink != 2)
1499		cifs_dbg(FYI, "unexpected number of links %d\n",
1500			 newinode->i_nlink);
1501#endif
1502
1503posix_mkdir_out:
1504	kfree(info);
1505	return rc;
1506posix_mkdir_get_info:
1507	rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1508			      xid);
1509	goto posix_mkdir_out;
1510}
1511
1512int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1513{
1514	int rc = 0;
1515	unsigned int xid;
1516	struct cifs_sb_info *cifs_sb;
1517	struct tcon_link *tlink;
1518	struct cifs_tcon *tcon;
1519	struct TCP_Server_Info *server;
1520	char *full_path;
1521
1522	cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1523		 mode, inode);
1524
1525	cifs_sb = CIFS_SB(inode->i_sb);
1526	tlink = cifs_sb_tlink(cifs_sb);
1527	if (IS_ERR(tlink))
1528		return PTR_ERR(tlink);
1529	tcon = tlink_tcon(tlink);
1530
1531	xid = get_xid();
1532
1533	full_path = build_path_from_dentry(direntry);
1534	if (full_path == NULL) {
1535		rc = -ENOMEM;
1536		goto mkdir_out;
1537	}
1538
 
 
 
 
 
 
 
 
 
1539	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1540				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1541		rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1542				      tcon, xid);
1543		if (rc != -EOPNOTSUPP)
1544			goto mkdir_out;
1545	}
1546
1547	server = tcon->ses->server;
1548
1549	if (!server->ops->mkdir) {
1550		rc = -ENOSYS;
1551		goto mkdir_out;
1552	}
1553
1554	/* BB add setting the equivalent of mode via CreateX w/ACLs */
1555	rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1556	if (rc) {
1557		cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1558		d_drop(direntry);
1559		goto mkdir_out;
1560	}
1561
 
1562	rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1563			      xid);
1564mkdir_out:
1565	/*
1566	 * Force revalidate to get parent dir info when needed since cached
1567	 * attributes are invalid now.
1568	 */
1569	CIFS_I(inode)->time = 0;
1570	kfree(full_path);
1571	free_xid(xid);
1572	cifs_put_tlink(tlink);
1573	return rc;
1574}
1575
1576int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1577{
1578	int rc = 0;
1579	unsigned int xid;
1580	struct cifs_sb_info *cifs_sb;
1581	struct tcon_link *tlink;
1582	struct cifs_tcon *tcon;
1583	struct TCP_Server_Info *server;
1584	char *full_path = NULL;
1585	struct cifsInodeInfo *cifsInode;
1586
1587	cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1588
1589	xid = get_xid();
1590
1591	full_path = build_path_from_dentry(direntry);
1592	if (full_path == NULL) {
1593		rc = -ENOMEM;
1594		goto rmdir_exit;
1595	}
1596
1597	cifs_sb = CIFS_SB(inode->i_sb);
1598	tlink = cifs_sb_tlink(cifs_sb);
1599	if (IS_ERR(tlink)) {
1600		rc = PTR_ERR(tlink);
1601		goto rmdir_exit;
1602	}
1603	tcon = tlink_tcon(tlink);
1604	server = tcon->ses->server;
1605
1606	if (!server->ops->rmdir) {
1607		rc = -ENOSYS;
1608		cifs_put_tlink(tlink);
1609		goto rmdir_exit;
1610	}
1611
1612	rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1613	cifs_put_tlink(tlink);
1614
1615	if (!rc) {
1616		spin_lock(&d_inode(direntry)->i_lock);
1617		i_size_write(d_inode(direntry), 0);
1618		clear_nlink(d_inode(direntry));
1619		spin_unlock(&d_inode(direntry)->i_lock);
1620	}
1621
1622	cifsInode = CIFS_I(d_inode(direntry));
1623	/* force revalidate to go get info when needed */
1624	cifsInode->time = 0;
1625
1626	cifsInode = CIFS_I(inode);
1627	/*
1628	 * Force revalidate to get parent dir info when needed since cached
1629	 * attributes are invalid now.
1630	 */
1631	cifsInode->time = 0;
1632
1633	d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1634		current_fs_time(inode->i_sb);
1635
1636rmdir_exit:
1637	kfree(full_path);
1638	free_xid(xid);
1639	return rc;
1640}
1641
1642static int
1643cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1644	       const char *from_path, struct dentry *to_dentry,
1645	       const char *to_path)
1646{
1647	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1648	struct tcon_link *tlink;
1649	struct cifs_tcon *tcon;
1650	struct TCP_Server_Info *server;
1651	struct cifs_fid fid;
1652	struct cifs_open_parms oparms;
1653	int oplock, rc;
1654
1655	tlink = cifs_sb_tlink(cifs_sb);
1656	if (IS_ERR(tlink))
1657		return PTR_ERR(tlink);
1658	tcon = tlink_tcon(tlink);
1659	server = tcon->ses->server;
1660
1661	if (!server->ops->rename)
1662		return -ENOSYS;
1663
1664	/* try path-based rename first */
1665	rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1666
1667	/*
1668	 * Don't bother with rename by filehandle unless file is busy and
1669	 * source. Note that cross directory moves do not work with
1670	 * rename by filehandle to various Windows servers.
1671	 */
1672	if (rc == 0 || rc != -EBUSY)
1673		goto do_rename_exit;
1674
 
 
 
 
1675	/* open-file renames don't work across directories */
1676	if (to_dentry->d_parent != from_dentry->d_parent)
1677		goto do_rename_exit;
1678
1679	oparms.tcon = tcon;
1680	oparms.cifs_sb = cifs_sb;
1681	/* open the file to be renamed -- we need DELETE perms */
1682	oparms.desired_access = DELETE;
1683	oparms.create_options = CREATE_NOT_DIR;
1684	oparms.disposition = FILE_OPEN;
1685	oparms.path = from_path;
1686	oparms.fid = &fid;
1687	oparms.reconnect = false;
1688
1689	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1690	if (rc == 0) {
1691		rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1692				(const char *) to_dentry->d_name.name,
1693				cifs_sb->local_nls, cifs_remap(cifs_sb));
1694		CIFSSMBClose(xid, tcon, fid.netfid);
1695	}
1696do_rename_exit:
1697	cifs_put_tlink(tlink);
1698	return rc;
1699}
1700
1701int
1702cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1703	     struct inode *target_dir, struct dentry *target_dentry,
1704	     unsigned int flags)
1705{
1706	char *from_name = NULL;
1707	char *to_name = NULL;
1708	struct cifs_sb_info *cifs_sb;
1709	struct tcon_link *tlink;
1710	struct cifs_tcon *tcon;
1711	FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1712	FILE_UNIX_BASIC_INFO *info_buf_target;
1713	unsigned int xid;
1714	int rc, tmprc;
1715
1716	if (flags & ~RENAME_NOREPLACE)
1717		return -EINVAL;
1718
1719	cifs_sb = CIFS_SB(source_dir->i_sb);
1720	tlink = cifs_sb_tlink(cifs_sb);
1721	if (IS_ERR(tlink))
1722		return PTR_ERR(tlink);
1723	tcon = tlink_tcon(tlink);
1724
1725	xid = get_xid();
1726
1727	/*
1728	 * we already have the rename sem so we do not need to
1729	 * grab it again here to protect the path integrity
1730	 */
1731	from_name = build_path_from_dentry(source_dentry);
1732	if (from_name == NULL) {
1733		rc = -ENOMEM;
1734		goto cifs_rename_exit;
1735	}
1736
1737	to_name = build_path_from_dentry(target_dentry);
1738	if (to_name == NULL) {
1739		rc = -ENOMEM;
1740		goto cifs_rename_exit;
1741	}
1742
1743	rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1744			    to_name);
1745
1746	/*
1747	 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1748	 */
1749	if (flags & RENAME_NOREPLACE)
1750		goto cifs_rename_exit;
1751
1752	if (rc == -EEXIST && tcon->unix_ext) {
1753		/*
1754		 * Are src and dst hardlinks of same inode? We can only tell
1755		 * with unix extensions enabled.
1756		 */
1757		info_buf_source =
1758			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1759					GFP_KERNEL);
1760		if (info_buf_source == NULL) {
1761			rc = -ENOMEM;
1762			goto cifs_rename_exit;
1763		}
1764
1765		info_buf_target = info_buf_source + 1;
1766		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1767					     info_buf_source,
1768					     cifs_sb->local_nls,
1769					     cifs_remap(cifs_sb));
1770		if (tmprc != 0)
1771			goto unlink_target;
1772
1773		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1774					     info_buf_target,
1775					     cifs_sb->local_nls,
1776					     cifs_remap(cifs_sb));
1777
1778		if (tmprc == 0 && (info_buf_source->UniqueId ==
1779				   info_buf_target->UniqueId)) {
1780			/* same file, POSIX says that this is a noop */
1781			rc = 0;
1782			goto cifs_rename_exit;
1783		}
1784	}
1785	/*
1786	 * else ... BB we could add the same check for Windows by
1787	 * checking the UniqueId via FILE_INTERNAL_INFO
1788	 */
1789
1790unlink_target:
1791	/* Try unlinking the target dentry if it's not negative */
1792	if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1793		if (d_is_dir(target_dentry))
1794			tmprc = cifs_rmdir(target_dir, target_dentry);
1795		else
1796			tmprc = cifs_unlink(target_dir, target_dentry);
1797		if (tmprc)
1798			goto cifs_rename_exit;
1799		rc = cifs_do_rename(xid, source_dentry, from_name,
1800				    target_dentry, to_name);
1801	}
1802
1803	/* force revalidate to go get info when needed */
1804	CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1805
1806	source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1807		target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1808
1809cifs_rename_exit:
1810	kfree(info_buf_source);
1811	kfree(from_name);
1812	kfree(to_name);
1813	free_xid(xid);
1814	cifs_put_tlink(tlink);
1815	return rc;
1816}
1817
1818static bool
1819cifs_inode_needs_reval(struct inode *inode)
1820{
1821	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1822	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1823
 
 
 
1824	if (CIFS_CACHE_READ(cifs_i))
1825		return false;
1826
1827	if (!lookupCacheEnabled)
1828		return true;
1829
1830	if (cifs_i->time == 0)
1831		return true;
1832
1833	if (!cifs_sb->actimeo)
1834		return true;
1835
1836	if (!time_in_range(jiffies, cifs_i->time,
1837				cifs_i->time + cifs_sb->actimeo))
1838		return true;
1839
1840	/* hardlinked files w/ noserverino get "special" treatment */
1841	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1842	    S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1843		return true;
1844
1845	return false;
1846}
1847
1848/*
1849 * Zap the cache. Called when invalid_mapping flag is set.
1850 */
1851int
1852cifs_invalidate_mapping(struct inode *inode)
1853{
1854	int rc = 0;
1855
1856	if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1857		rc = invalidate_inode_pages2(inode->i_mapping);
1858		if (rc)
1859			cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1860				 __func__, inode);
1861	}
1862
1863	cifs_fscache_reset_inode_cookie(inode);
1864	return rc;
1865}
1866
1867/**
1868 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1869 * @word: long word containing the bit lock
1870 */
1871static int
1872cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1873{
1874	freezable_schedule_unsafe();
1875	if (signal_pending_state(mode, current))
1876		return -ERESTARTSYS;
1877	return 0;
1878}
1879
1880int
1881cifs_revalidate_mapping(struct inode *inode)
1882{
1883	int rc;
1884	unsigned long *flags = &CIFS_I(inode)->flags;
1885
1886	rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1887				     TASK_KILLABLE);
1888	if (rc)
1889		return rc;
1890
1891	if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1892		rc = cifs_invalidate_mapping(inode);
1893		if (rc)
1894			set_bit(CIFS_INO_INVALID_MAPPING, flags);
1895	}
1896
1897	clear_bit_unlock(CIFS_INO_LOCK, flags);
1898	smp_mb__after_atomic();
1899	wake_up_bit(flags, CIFS_INO_LOCK);
1900
1901	return rc;
1902}
1903
1904int
1905cifs_zap_mapping(struct inode *inode)
1906{
1907	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1908	return cifs_revalidate_mapping(inode);
1909}
1910
1911int cifs_revalidate_file_attr(struct file *filp)
1912{
1913	int rc = 0;
1914	struct inode *inode = file_inode(filp);
1915	struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1916
1917	if (!cifs_inode_needs_reval(inode))
1918		return rc;
1919
1920	if (tlink_tcon(cfile->tlink)->unix_ext)
1921		rc = cifs_get_file_info_unix(filp);
1922	else
1923		rc = cifs_get_file_info(filp);
1924
1925	return rc;
1926}
1927
1928int cifs_revalidate_dentry_attr(struct dentry *dentry)
1929{
1930	unsigned int xid;
1931	int rc = 0;
1932	struct inode *inode = d_inode(dentry);
1933	struct super_block *sb = dentry->d_sb;
1934	char *full_path = NULL;
1935
1936	if (inode == NULL)
1937		return -ENOENT;
1938
1939	if (!cifs_inode_needs_reval(inode))
1940		return rc;
1941
1942	xid = get_xid();
1943
1944	/* can not safely grab the rename sem here if rename calls revalidate
1945	   since that would deadlock */
1946	full_path = build_path_from_dentry(dentry);
1947	if (full_path == NULL) {
1948		rc = -ENOMEM;
1949		goto out;
1950	}
1951
1952	cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1953		 full_path, inode, inode->i_count.counter,
1954		 dentry, cifs_get_time(dentry), jiffies);
1955
1956	if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1957		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1958	else
1959		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1960					 xid, NULL);
1961
1962out:
1963	kfree(full_path);
1964	free_xid(xid);
1965	return rc;
1966}
1967
1968int cifs_revalidate_file(struct file *filp)
1969{
1970	int rc;
1971	struct inode *inode = file_inode(filp);
1972
1973	rc = cifs_revalidate_file_attr(filp);
1974	if (rc)
1975		return rc;
1976
1977	return cifs_revalidate_mapping(inode);
1978}
1979
1980/* revalidate a dentry's inode attributes */
1981int cifs_revalidate_dentry(struct dentry *dentry)
1982{
1983	int rc;
1984	struct inode *inode = d_inode(dentry);
1985
1986	rc = cifs_revalidate_dentry_attr(dentry);
1987	if (rc)
1988		return rc;
1989
1990	return cifs_revalidate_mapping(inode);
1991}
1992
1993int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1994		 struct kstat *stat)
1995{
 
1996	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1997	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1998	struct inode *inode = d_inode(dentry);
1999	int rc;
2000
2001	/*
2002	 * We need to be sure that all dirty pages are written and the server
2003	 * has actual ctime, mtime and file length.
2004	 */
2005	if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2006	    inode->i_mapping->nrpages != 0) {
2007		rc = filemap_fdatawait(inode->i_mapping);
2008		if (rc) {
2009			mapping_set_error(inode->i_mapping, rc);
2010			return rc;
2011		}
2012	}
2013
2014	rc = cifs_revalidate_dentry_attr(dentry);
2015	if (rc)
2016		return rc;
2017
2018	generic_fillattr(inode, stat);
2019	stat->blksize = CIFS_MAX_MSGSIZE;
2020	stat->ino = CIFS_I(inode)->uniqueid;
2021
 
 
 
 
 
 
 
 
 
 
 
 
 
2022	/*
2023	 * If on a multiuser mount without unix extensions or cifsacl being
2024	 * enabled, and the admin hasn't overridden them, set the ownership
2025	 * to the fsuid/fsgid of the current process.
2026	 */
2027	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2028	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2029	    !tcon->unix_ext) {
2030		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2031			stat->uid = current_fsuid();
2032		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2033			stat->gid = current_fsgid();
2034	}
2035	return rc;
2036}
2037
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2038static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2039{
2040	pgoff_t index = from >> PAGE_SHIFT;
2041	unsigned offset = from & (PAGE_SIZE - 1);
2042	struct page *page;
2043	int rc = 0;
2044
2045	page = grab_cache_page(mapping, index);
2046	if (!page)
2047		return -ENOMEM;
2048
2049	zero_user_segment(page, offset, PAGE_SIZE);
2050	unlock_page(page);
2051	put_page(page);
2052	return rc;
2053}
2054
2055static void cifs_setsize(struct inode *inode, loff_t offset)
2056{
 
 
2057	spin_lock(&inode->i_lock);
2058	i_size_write(inode, offset);
2059	spin_unlock(&inode->i_lock);
2060
 
 
2061	truncate_pagecache(inode, offset);
2062}
2063
2064static int
2065cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2066		   unsigned int xid, char *full_path)
2067{
2068	int rc;
2069	struct cifsFileInfo *open_file;
2070	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2071	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2072	struct tcon_link *tlink = NULL;
2073	struct cifs_tcon *tcon = NULL;
2074	struct TCP_Server_Info *server;
2075
2076	/*
2077	 * To avoid spurious oplock breaks from server, in the case of
2078	 * inodes that we already have open, avoid doing path based
2079	 * setting of file size if we can do it by handle.
2080	 * This keeps our caching token (oplock) and avoids timeouts
2081	 * when the local oplock break takes longer to flush
2082	 * writebehind data than the SMB timeout for the SetPathInfo
2083	 * request would allow
2084	 */
2085	open_file = find_writable_file(cifsInode, true);
2086	if (open_file) {
2087		tcon = tlink_tcon(open_file->tlink);
2088		server = tcon->ses->server;
2089		if (server->ops->set_file_size)
2090			rc = server->ops->set_file_size(xid, tcon, open_file,
2091							attrs->ia_size, false);
2092		else
2093			rc = -ENOSYS;
2094		cifsFileInfo_put(open_file);
2095		cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2096	} else
2097		rc = -EINVAL;
2098
2099	if (!rc)
2100		goto set_size_out;
2101
2102	if (tcon == NULL) {
2103		tlink = cifs_sb_tlink(cifs_sb);
2104		if (IS_ERR(tlink))
2105			return PTR_ERR(tlink);
2106		tcon = tlink_tcon(tlink);
2107		server = tcon->ses->server;
2108	}
2109
2110	/*
2111	 * Set file size by pathname rather than by handle either because no
2112	 * valid, writeable file handle for it was found or because there was
2113	 * an error setting it by handle.
2114	 */
2115	if (server->ops->set_path_size)
2116		rc = server->ops->set_path_size(xid, tcon, full_path,
2117						attrs->ia_size, cifs_sb, false);
2118	else
2119		rc = -ENOSYS;
2120	cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2121
2122	if (tlink)
2123		cifs_put_tlink(tlink);
2124
2125set_size_out:
2126	if (rc == 0) {
2127		cifsInode->server_eof = attrs->ia_size;
2128		cifs_setsize(inode, attrs->ia_size);
2129		cifs_truncate_page(inode->i_mapping, inode->i_size);
2130	}
2131
2132	return rc;
2133}
2134
2135static int
2136cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2137{
2138	int rc;
2139	unsigned int xid;
2140	char *full_path = NULL;
2141	struct inode *inode = d_inode(direntry);
2142	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2143	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2144	struct tcon_link *tlink;
2145	struct cifs_tcon *pTcon;
2146	struct cifs_unix_set_info_args *args = NULL;
2147	struct cifsFileInfo *open_file;
2148
2149	cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2150		 direntry, attrs->ia_valid);
2151
2152	xid = get_xid();
2153
2154	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2155		attrs->ia_valid |= ATTR_FORCE;
2156
2157	rc = setattr_prepare(direntry, attrs);
2158	if (rc < 0)
2159		goto out;
2160
2161	full_path = build_path_from_dentry(direntry);
2162	if (full_path == NULL) {
2163		rc = -ENOMEM;
2164		goto out;
2165	}
2166
2167	/*
2168	 * Attempt to flush data before changing attributes. We need to do
2169	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2170	 * ownership or mode then we may also need to do this. Here, we take
2171	 * the safe way out and just do the flush on all setattr requests. If
2172	 * the flush returns error, store it to report later and continue.
2173	 *
2174	 * BB: This should be smarter. Why bother flushing pages that
2175	 * will be truncated anyway? Also, should we error out here if
2176	 * the flush returns error?
2177	 */
2178	rc = filemap_write_and_wait(inode->i_mapping);
 
 
 
 
 
2179	mapping_set_error(inode->i_mapping, rc);
2180	rc = 0;
2181
2182	if (attrs->ia_valid & ATTR_SIZE) {
2183		rc = cifs_set_file_size(inode, attrs, xid, full_path);
2184		if (rc != 0)
2185			goto out;
2186	}
2187
2188	/* skip mode change if it's just for clearing setuid/setgid */
2189	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2190		attrs->ia_valid &= ~ATTR_MODE;
2191
2192	args = kmalloc(sizeof(*args), GFP_KERNEL);
2193	if (args == NULL) {
2194		rc = -ENOMEM;
2195		goto out;
2196	}
2197
2198	/* set up the struct */
2199	if (attrs->ia_valid & ATTR_MODE)
2200		args->mode = attrs->ia_mode;
2201	else
2202		args->mode = NO_CHANGE_64;
2203
2204	if (attrs->ia_valid & ATTR_UID)
2205		args->uid = attrs->ia_uid;
2206	else
2207		args->uid = INVALID_UID; /* no change */
2208
2209	if (attrs->ia_valid & ATTR_GID)
2210		args->gid = attrs->ia_gid;
2211	else
2212		args->gid = INVALID_GID; /* no change */
2213
2214	if (attrs->ia_valid & ATTR_ATIME)
2215		args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2216	else
2217		args->atime = NO_CHANGE_64;
2218
2219	if (attrs->ia_valid & ATTR_MTIME)
2220		args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2221	else
2222		args->mtime = NO_CHANGE_64;
2223
2224	if (attrs->ia_valid & ATTR_CTIME)
2225		args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2226	else
2227		args->ctime = NO_CHANGE_64;
2228
2229	args->device = 0;
2230	open_file = find_writable_file(cifsInode, true);
2231	if (open_file) {
2232		u16 nfid = open_file->fid.netfid;
2233		u32 npid = open_file->pid;
2234		pTcon = tlink_tcon(open_file->tlink);
2235		rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2236		cifsFileInfo_put(open_file);
2237	} else {
2238		tlink = cifs_sb_tlink(cifs_sb);
2239		if (IS_ERR(tlink)) {
2240			rc = PTR_ERR(tlink);
2241			goto out;
2242		}
2243		pTcon = tlink_tcon(tlink);
2244		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2245				    cifs_sb->local_nls,
2246				    cifs_remap(cifs_sb));
2247		cifs_put_tlink(tlink);
2248	}
2249
2250	if (rc)
2251		goto out;
2252
2253	if ((attrs->ia_valid & ATTR_SIZE) &&
2254	    attrs->ia_size != i_size_read(inode))
2255		truncate_setsize(inode, attrs->ia_size);
2256
2257	setattr_copy(inode, attrs);
2258	mark_inode_dirty(inode);
2259
2260	/* force revalidate when any of these times are set since some
2261	   of the fs types (eg ext3, fat) do not have fine enough
2262	   time granularity to match protocol, and we do not have a
2263	   a way (yet) to query the server fs's time granularity (and
2264	   whether it rounds times down).
2265	*/
2266	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2267		cifsInode->time = 0;
2268out:
2269	kfree(args);
2270	kfree(full_path);
2271	free_xid(xid);
2272	return rc;
2273}
2274
2275static int
2276cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2277{
2278	unsigned int xid;
2279	kuid_t uid = INVALID_UID;
2280	kgid_t gid = INVALID_GID;
2281	struct inode *inode = d_inode(direntry);
2282	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2283	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
 
 
2284	char *full_path = NULL;
2285	int rc = -EACCES;
2286	__u32 dosattr = 0;
2287	__u64 mode = NO_CHANGE_64;
2288
2289	xid = get_xid();
2290
2291	cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2292		 direntry, attrs->ia_valid);
2293
2294	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2295		attrs->ia_valid |= ATTR_FORCE;
2296
2297	rc = setattr_prepare(direntry, attrs);
2298	if (rc < 0) {
2299		free_xid(xid);
2300		return rc;
2301	}
2302
2303	full_path = build_path_from_dentry(direntry);
2304	if (full_path == NULL) {
2305		rc = -ENOMEM;
2306		free_xid(xid);
2307		return rc;
2308	}
2309
2310	/*
2311	 * Attempt to flush data before changing attributes. We need to do
2312	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2313	 * ownership or mode then we may also need to do this. Here, we take
2314	 * the safe way out and just do the flush on all setattr requests. If
2315	 * the flush returns error, store it to report later and continue.
2316	 *
2317	 * BB: This should be smarter. Why bother flushing pages that
2318	 * will be truncated anyway? Also, should we error out here if
2319	 * the flush returns error?
2320	 */
2321	rc = filemap_write_and_wait(inode->i_mapping);
 
 
 
 
 
2322	mapping_set_error(inode->i_mapping, rc);
2323	rc = 0;
2324
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2325	if (attrs->ia_valid & ATTR_SIZE) {
2326		rc = cifs_set_file_size(inode, attrs, xid, full_path);
2327		if (rc != 0)
2328			goto cifs_setattr_exit;
2329	}
2330
2331	if (attrs->ia_valid & ATTR_UID)
2332		uid = attrs->ia_uid;
2333
2334	if (attrs->ia_valid & ATTR_GID)
2335		gid = attrs->ia_gid;
2336
2337#ifdef CONFIG_CIFS_ACL
2338	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2339		if (uid_valid(uid) || gid_valid(gid)) {
2340			rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2341							uid, gid);
2342			if (rc) {
2343				cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2344					 __func__, rc);
2345				goto cifs_setattr_exit;
2346			}
2347		}
2348	} else
2349#endif /* CONFIG_CIFS_ACL */
2350	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2351		attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2352
2353	/* skip mode change if it's just for clearing setuid/setgid */
2354	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2355		attrs->ia_valid &= ~ATTR_MODE;
2356
2357	if (attrs->ia_valid & ATTR_MODE) {
2358		mode = attrs->ia_mode;
2359		rc = 0;
2360#ifdef CONFIG_CIFS_ACL
2361		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2362			rc = id_mode_to_cifs_acl(inode, full_path, mode,
2363						INVALID_UID, INVALID_GID);
2364			if (rc) {
2365				cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2366					 __func__, rc);
2367				goto cifs_setattr_exit;
2368			}
2369		} else
2370#endif /* CONFIG_CIFS_ACL */
2371		if (((mode & S_IWUGO) == 0) &&
2372		    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2373
2374			dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2375
2376			/* fix up mode if we're not using dynperm */
2377			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2378				attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2379		} else if ((mode & S_IWUGO) &&
2380			   (cifsInode->cifsAttrs & ATTR_READONLY)) {
2381
2382			dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2383			/* Attributes of 0 are ignored */
2384			if (dosattr == 0)
2385				dosattr |= ATTR_NORMAL;
2386
2387			/* reset local inode permissions to normal */
2388			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2389				attrs->ia_mode &= ~(S_IALLUGO);
2390				if (S_ISDIR(inode->i_mode))
2391					attrs->ia_mode |=
2392						cifs_sb->mnt_dir_mode;
2393				else
2394					attrs->ia_mode |=
2395						cifs_sb->mnt_file_mode;
2396			}
2397		} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2398			/* ignore mode change - ATTR_READONLY hasn't changed */
2399			attrs->ia_valid &= ~ATTR_MODE;
2400		}
2401	}
2402
2403	if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2404	    ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2405		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2406		/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2407
2408		/* Even if error on time set, no sense failing the call if
2409		the server would set the time to a reasonable value anyway,
2410		and this check ensures that we are not being called from
2411		sys_utimes in which case we ought to fail the call back to
2412		the user when the server rejects the call */
2413		if ((rc) && (attrs->ia_valid &
2414				(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2415			rc = 0;
2416	}
2417
2418	/* do not need local check to inode_check_ok since the server does
2419	   that */
2420	if (rc)
2421		goto cifs_setattr_exit;
2422
2423	if ((attrs->ia_valid & ATTR_SIZE) &&
2424	    attrs->ia_size != i_size_read(inode))
2425		truncate_setsize(inode, attrs->ia_size);
2426
2427	setattr_copy(inode, attrs);
2428	mark_inode_dirty(inode);
2429
2430cifs_setattr_exit:
2431	kfree(full_path);
2432	free_xid(xid);
2433	return rc;
2434}
2435
2436int
2437cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2438{
2439	struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2440	struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2441
2442	if (pTcon->unix_ext)
2443		return cifs_setattr_unix(direntry, attrs);
2444
2445	return cifs_setattr_nounix(direntry, attrs);
2446
2447	/* BB: add cifs_setattr_legacy for really old servers */
2448}
2449
2450#if 0
2451void cifs_delete_inode(struct inode *inode)
2452{
2453	cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2454	/* may have to add back in if and when safe distributed caching of
2455	   directories added e.g. via FindNotify */
2456}
2457#endif