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