1// SPDX-License-Identifier: LGPL-2.1
   2/*
   3 *
   4 *   Copyright (C) International Business Machines  Corp., 2002,2010
   5 *   Author(s): Steve French (sfrench@us.ibm.com)
   6 *
   7 */
   8#include <linux/fs.h>
   9#include <linux/stat.h>
  10#include <linux/slab.h>
  11#include <linux/pagemap.h>
  12#include <linux/freezer.h>
  13#include <linux/sched/signal.h>
  14#include <linux/wait_bit.h>
  15#include <linux/fiemap.h>
  16#include <asm/div64.h>
  17#include "cifsfs.h"
  18#include "cifspdu.h"
  19#include "cifsglob.h"
  20#include "cifsproto.h"
  21#include "smb2proto.h"
  22#include "cifs_debug.h"
  23#include "cifs_fs_sb.h"
  24#include "cifs_unicode.h"
  25#include "fscache.h"
  26#include "fs_context.h"
  27#include "cifs_ioctl.h"
  28#include "cached_dir.h"
  29#include "reparse.h"
  30
  31/*
  32 * Set parameters for the netfs library
  33 */
  34static void cifs_set_netfs_context(struct inode *inode)
  35{
  36	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  37
  38	netfs_inode_init(&cifs_i->netfs, &cifs_req_ops, true);
  39}
  40
  41static void cifs_set_ops(struct inode *inode)
  42{
  43	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  44	struct netfs_inode *ictx = netfs_inode(inode);
  45
  46	switch (inode->i_mode & S_IFMT) {
  47	case S_IFREG:
  48		inode->i_op = &cifs_file_inode_ops;
  49		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  50			set_bit(NETFS_ICTX_UNBUFFERED, &ictx->flags);
  51			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  52				inode->i_fop = &cifs_file_direct_nobrl_ops;
  53			else
  54				inode->i_fop = &cifs_file_direct_ops;
  55		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  56			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  57				inode->i_fop = &cifs_file_strict_nobrl_ops;
  58			else
  59				inode->i_fop = &cifs_file_strict_ops;
  60		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  61			inode->i_fop = &cifs_file_nobrl_ops;
  62		else { /* not direct, send byte range locks */
  63			inode->i_fop = &cifs_file_ops;
  64		}
  65
  66		/* check if server can support readahead */
  67		if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
  68				PAGE_SIZE + MAX_CIFS_HDR_SIZE)
  69			inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  70		else
  71			inode->i_data.a_ops = &cifs_addr_ops;
  72		mapping_set_large_folios(inode->i_mapping);
  73		break;
  74	case S_IFDIR:
  75		if (IS_AUTOMOUNT(inode)) {
  76			inode->i_op = &cifs_namespace_inode_operations;
  77		} else {
  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 cifs_fscache_inode_coherency_data cd;
  98	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  99	struct timespec64 mtime;
 100
 101	cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 102		 __func__, cifs_i->uniqueid);
 103
 104	if (inode->i_state & I_NEW) {
 105		cifs_dbg(FYI, "%s: inode %llu is new\n",
 106			 __func__, cifs_i->uniqueid);
 107		return;
 108	}
 109
 110	/* don't bother with revalidation if we have an oplock */
 111	if (CIFS_CACHE_READ(cifs_i)) {
 112		cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 113			 __func__, cifs_i->uniqueid);
 114		return;
 115	}
 116
 117	 /* revalidate if mtime or size have changed */
 118	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
 119	mtime = inode_get_mtime(inode);
 120	if (timespec64_equal(&mtime, &fattr->cf_mtime) &&
 121	    cifs_i->netfs.remote_i_size == fattr->cf_eof) {
 122		cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 123			 __func__, cifs_i->uniqueid);
 124		return;
 125	}
 126
 127	cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 128		 __func__, cifs_i->uniqueid);
 129	set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 130	/* Invalidate fscache cookie */
 131	cifs_fscache_fill_coherency(&cifs_i->netfs.inode, &cd);
 132	fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
 133}
 134
 135/*
 136 * copy nlink to the inode, unless it wasn't provided.  Provide
 137 * sane values if we don't have an existing one and none was provided
 138 */
 139static void
 140cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 141{
 142	/*
 143	 * if we're in a situation where we can't trust what we
 144	 * got from the server (readdir, some non-unix cases)
 145	 * fake reasonable values
 146	 */
 147	if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 148		/* only provide fake values on a new inode */
 149		if (inode->i_state & I_NEW) {
 150			if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 151				set_nlink(inode, 2);
 152			else
 153				set_nlink(inode, 1);
 154		}
 155		return;
 156	}
 157
 158	/* we trust the server, so update it */
 159	set_nlink(inode, fattr->cf_nlink);
 160}
 161
 162/* populate an inode with info from a cifs_fattr struct */
 163int
 164cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,
 165		    bool from_readdir)
 166{
 167	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 168	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 169
 170	if (!(inode->i_state & I_NEW) &&
 171	    unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
 172		CIFS_I(inode)->time = 0; /* force reval */
 173		return -ESTALE;
 174	}
 175	if (inode->i_state & I_NEW)
 176		CIFS_I(inode)->netfs.zero_point = fattr->cf_eof;
 177
 178	cifs_revalidate_cache(inode, fattr);
 179
 180	spin_lock(&inode->i_lock);
 181	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
 182	fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
 183	fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
 184	/* we do not want atime to be less than mtime, it broke some apps */
 185	if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
 186		inode_set_atime_to_ts(inode, fattr->cf_mtime);
 187	else
 188		inode_set_atime_to_ts(inode, fattr->cf_atime);
 189	inode_set_mtime_to_ts(inode, fattr->cf_mtime);
 190	inode_set_ctime_to_ts(inode, fattr->cf_ctime);
 191	inode->i_rdev = fattr->cf_rdev;
 192	cifs_nlink_fattr_to_inode(inode, fattr);
 193	inode->i_uid = fattr->cf_uid;
 194	inode->i_gid = fattr->cf_gid;
 195
 196	/* if dynperm is set, don't clobber existing mode */
 197	if (inode->i_state & I_NEW ||
 198	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 199		inode->i_mode = fattr->cf_mode;
 200
 201	cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 202	cifs_i->reparse_tag = fattr->cf_cifstag;
 203
 204	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 205		cifs_i->time = 0;
 206	else
 207		cifs_i->time = jiffies;
 208
 209	if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
 210		set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 211	else
 212		clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 213
 214	cifs_i->netfs.remote_i_size = fattr->cf_eof;
 215	/*
 216	 * Can't safely change the file size here if the client is writing to
 217	 * it due to potential races.
 218	 */
 219	if (is_size_safe_to_change(cifs_i, fattr->cf_eof, from_readdir)) {
 220		i_size_write(inode, fattr->cf_eof);
 221
 222		/*
 223		 * i_blocks is not related to (i_size / i_blksize),
 224		 * but instead 512 byte (2**9) size is required for
 225		 * calculating num blocks.
 226		 */
 227		inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 228	}
 229
 230	if (S_ISLNK(fattr->cf_mode) && fattr->cf_symlink_target) {
 231		kfree(cifs_i->symlink_target);
 232		cifs_i->symlink_target = fattr->cf_symlink_target;
 233		fattr->cf_symlink_target = NULL;
 234	}
 235	spin_unlock(&inode->i_lock);
 236
 237	if (fattr->cf_flags & CIFS_FATTR_JUNCTION)
 238		inode->i_flags |= S_AUTOMOUNT;
 239	if (inode->i_state & I_NEW) {
 240		cifs_set_netfs_context(inode);
 241		cifs_set_ops(inode);
 242	}
 243	return 0;
 244}
 245
 246void
 247cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 248{
 249	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 250
 251	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 252		return;
 253
 254	fattr->cf_uniqueid = iunique(sb, ROOT_I);
 255}
 256
 257/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 258void
 259cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 260			 struct cifs_sb_info *cifs_sb)
 261{
 262	memset(fattr, 0, sizeof(*fattr));
 263	fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 264	fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 265	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 266
 267	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 268	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 269	fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 270	/* old POSIX extensions don't get create time */
 271
 272	fattr->cf_mode = le64_to_cpu(info->Permissions);
 273
 274	/*
 275	 * Since we set the inode type below we need to mask off
 276	 * to avoid strange results if bits set above.
 277	 */
 278	fattr->cf_mode &= ~S_IFMT;
 279	switch (le32_to_cpu(info->Type)) {
 280	case UNIX_FILE:
 281		fattr->cf_mode |= S_IFREG;
 282		fattr->cf_dtype = DT_REG;
 283		break;
 284	case UNIX_SYMLINK:
 285		fattr->cf_mode |= S_IFLNK;
 286		fattr->cf_dtype = DT_LNK;
 287		break;
 288	case UNIX_DIR:
 289		fattr->cf_mode |= S_IFDIR;
 290		fattr->cf_dtype = DT_DIR;
 291		break;
 292	case UNIX_CHARDEV:
 293		fattr->cf_mode |= S_IFCHR;
 294		fattr->cf_dtype = DT_CHR;
 295		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 296				       le64_to_cpu(info->DevMinor) & MINORMASK);
 297		break;
 298	case UNIX_BLOCKDEV:
 299		fattr->cf_mode |= S_IFBLK;
 300		fattr->cf_dtype = DT_BLK;
 301		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 302				       le64_to_cpu(info->DevMinor) & MINORMASK);
 303		break;
 304	case UNIX_FIFO:
 305		fattr->cf_mode |= S_IFIFO;
 306		fattr->cf_dtype = DT_FIFO;
 307		break;
 308	case UNIX_SOCKET:
 309		fattr->cf_mode |= S_IFSOCK;
 310		fattr->cf_dtype = DT_SOCK;
 311		break;
 312	default:
 313		/* safest to call it a file if we do not know */
 314		fattr->cf_mode |= S_IFREG;
 315		fattr->cf_dtype = DT_REG;
 316		cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 317		break;
 318	}
 319
 320	fattr->cf_uid = cifs_sb->ctx->linux_uid;
 321	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 322		u64 id = le64_to_cpu(info->Uid);
 323		if (id < ((uid_t)-1)) {
 324			kuid_t uid = make_kuid(&init_user_ns, id);
 325			if (uid_valid(uid))
 326				fattr->cf_uid = uid;
 327		}
 328	}
 329	
 330	fattr->cf_gid = cifs_sb->ctx->linux_gid;
 331	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 332		u64 id = le64_to_cpu(info->Gid);
 333		if (id < ((gid_t)-1)) {
 334			kgid_t gid = make_kgid(&init_user_ns, id);
 335			if (gid_valid(gid))
 336				fattr->cf_gid = gid;
 337		}
 338	}
 339
 340	fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 341}
 342
 343/*
 344 * Fill a cifs_fattr struct with fake inode info.
 345 *
 346 * Needed to setup cifs_fattr data for the directory which is the
 347 * junction to the new submount (ie to setup the fake directory
 348 * which represents a DFS referral or reparse mount point).
 349 */
 350static void cifs_create_junction_fattr(struct cifs_fattr *fattr,
 351				       struct super_block *sb)
 352{
 353	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 354
 355	cifs_dbg(FYI, "%s: creating fake fattr\n", __func__);
 356
 357	memset(fattr, 0, sizeof(*fattr));
 358	fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 359	fattr->cf_uid = cifs_sb->ctx->linux_uid;
 360	fattr->cf_gid = cifs_sb->ctx->linux_gid;
 361	ktime_get_coarse_real_ts64(&fattr->cf_mtime);
 362	fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
 363	fattr->cf_nlink = 2;
 364	fattr->cf_flags = CIFS_FATTR_JUNCTION;
 365}
 366
 367/* Update inode with final fattr data */
 368static int update_inode_info(struct super_block *sb,
 369			     struct cifs_fattr *fattr,
 370			     struct inode **inode)
 371{
 372	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 373	int rc = 0;
 374
 375	if (!*inode) {
 376		*inode = cifs_iget(sb, fattr);
 377		if (!*inode)
 378			rc = -ENOMEM;
 379		return rc;
 380	}
 381	/* We already have inode, update it.
 382	 *
 383	 * If file type or uniqueid is different, return error.
 384	 */
 385	if (unlikely((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
 386		     CIFS_I(*inode)->uniqueid != fattr->cf_uniqueid)) {
 387		CIFS_I(*inode)->time = 0; /* force reval */
 388		return -ESTALE;
 389	}
 390	return cifs_fattr_to_inode(*inode, fattr, false);
 391}
 392
 393#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 394static int
 395cifs_get_file_info_unix(struct file *filp)
 396{
 397	int rc;
 398	unsigned int xid;
 399	FILE_UNIX_BASIC_INFO find_data;
 400	struct cifs_fattr fattr = {};
 401	struct inode *inode = file_inode(filp);
 402	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 403	struct cifsFileInfo *cfile = filp->private_data;
 404	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 405
 406	xid = get_xid();
 407
 408	if (cfile->symlink_target) {
 409		fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
 410		if (!fattr.cf_symlink_target) {
 411			rc = -ENOMEM;
 412			goto cifs_gfiunix_out;
 413		}
 414	}
 415
 416	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 417	if (!rc) {
 418		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 419	} else if (rc == -EREMOTE) {
 420		cifs_create_junction_fattr(&fattr, inode->i_sb);
 421	} else
 422		goto cifs_gfiunix_out;
 423
 424	rc = cifs_fattr_to_inode(inode, &fattr, false);
 425
 426cifs_gfiunix_out:
 427	free_xid(xid);
 428	return rc;
 429}
 430
 431static int cifs_get_unix_fattr(const unsigned char *full_path,
 432			       struct super_block *sb,
 433			       struct cifs_fattr *fattr,
 434			       struct inode **pinode,
 435			       const unsigned int xid)
 436{
 437	struct TCP_Server_Info *server;
 438	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 439	FILE_UNIX_BASIC_INFO find_data;
 440	struct cifs_tcon *tcon;
 441	struct tcon_link *tlink;
 442	int rc, tmprc;
 443
 444	cifs_dbg(FYI, "Getting info on %s\n", full_path);
 445
 446	tlink = cifs_sb_tlink(cifs_sb);
 447	if (IS_ERR(tlink))
 448		return PTR_ERR(tlink);
 449	tcon = tlink_tcon(tlink);
 450	server = tcon->ses->server;
 451
 452	/* could have done a find first instead but this returns more info */
 453	rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 454				  cifs_sb->local_nls, cifs_remap(cifs_sb));
 455	cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc);
 456	cifs_put_tlink(tlink);
 457
 458	if (!rc) {
 459		cifs_unix_basic_to_fattr(fattr, &find_data, cifs_sb);
 460	} else if (rc == -EREMOTE) {
 461		cifs_create_junction_fattr(fattr, sb);
 462		rc = 0;
 463	} else {
 464		return rc;
 465	}
 466
 467	if (!*pinode)
 468		cifs_fill_uniqueid(sb, fattr);
 469
 470	/* check for Minshall+French symlinks */
 471	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 472		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
 473		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 474	}
 475
 476	if (S_ISLNK(fattr->cf_mode) && !fattr->cf_symlink_target) {
 477		if (!server->ops->query_symlink)
 478			return -EOPNOTSUPP;
 479		rc = server->ops->query_symlink(xid, tcon,
 480						cifs_sb, full_path,
 481						&fattr->cf_symlink_target);
 482		cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc);
 483	}
 484	return rc;
 485}
 486
 487int cifs_get_inode_info_unix(struct inode **pinode,
 488			     const unsigned char *full_path,
 489			     struct super_block *sb, unsigned int xid)
 490{
 491	struct cifs_fattr fattr = {};
 492	int rc;
 493
 494	rc = cifs_get_unix_fattr(full_path, sb, &fattr, pinode, xid);
 495	if (rc)
 496		goto out;
 497
 498	rc = update_inode_info(sb, &fattr, pinode);
 499out:
 500	kfree(fattr.cf_symlink_target);
 501	return rc;
 502}
 503#else
 504static inline int cifs_get_unix_fattr(const unsigned char *full_path,
 505				      struct super_block *sb,
 506				      struct cifs_fattr *fattr,
 507				      struct inode **pinode,
 508				      const unsigned int xid)
 509{
 510	return -EOPNOTSUPP;
 511}
 512
 513int cifs_get_inode_info_unix(struct inode **pinode,
 514			     const unsigned char *full_path,
 515			     struct super_block *sb, unsigned int xid)
 516{
 517	return -EOPNOTSUPP;
 518}
 519#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 520
 521static int
 522cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
 523	      struct cifs_sb_info *cifs_sb, unsigned int xid)
 524{
 525	int rc;
 526	__u32 oplock;
 527	struct tcon_link *tlink;
 528	struct cifs_tcon *tcon;
 529	struct cifs_fid fid;
 530	struct cifs_open_parms oparms;
 531	struct cifs_io_parms io_parms = {0};
 532	char *symlink_buf_utf16;
 533	unsigned int symlink_len_utf16;
 534	char buf[24];
 535	unsigned int bytes_read;
 536	char *pbuf;
 537	int buf_type = CIFS_NO_BUFFER;
 538
 539	pbuf = buf;
 540
 541	fattr->cf_mode &= ~S_IFMT;
 542
 543	if (fattr->cf_eof == 0) {
 544		cifs_dbg(FYI, "Fifo\n");
 545		fattr->cf_mode |= S_IFIFO;
 546		fattr->cf_dtype = DT_FIFO;
 547		return 0;
 548	} else if (fattr->cf_eof > 1 && fattr->cf_eof < 8) {
 549		fattr->cf_mode |= S_IFREG;
 550		fattr->cf_dtype = DT_REG;
 551		return -EINVAL;	 /* EOPNOTSUPP? */
 552	}
 553
 554	tlink = cifs_sb_tlink(cifs_sb);
 555	if (IS_ERR(tlink))
 556		return PTR_ERR(tlink);
 557	tcon = tlink_tcon(tlink);
 558
 559	oparms = (struct cifs_open_parms) {
 560		.tcon = tcon,
 561		.cifs_sb = cifs_sb,
 562		.desired_access = GENERIC_READ,
 563		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
 564		.disposition = FILE_OPEN,
 565		.path = path,
 566		.fid = &fid,
 567	};
 568
 569	if (tcon->ses->server->oplocks)
 570		oplock = REQ_OPLOCK;
 571	else
 572		oplock = 0;
 573	rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
 574	if (rc) {
 575		cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
 576		cifs_put_tlink(tlink);
 577		return rc;
 578	}
 579
 580	/* Read header */
 581	io_parms.netfid = fid.netfid;
 582	io_parms.pid = current->tgid;
 583	io_parms.tcon = tcon;
 584	io_parms.offset = 0;
 585	io_parms.length = 24;
 586
 587	rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
 588					&bytes_read, &pbuf, &buf_type);
 589	if ((rc == 0) && (bytes_read >= 8)) {
 590		if (memcmp("IntxBLK\0", pbuf, 8) == 0) {
 591			cifs_dbg(FYI, "Block device\n");
 592			fattr->cf_mode |= S_IFBLK;
 593			fattr->cf_dtype = DT_BLK;
 594			if (bytes_read == 24) {
 595				/* we have enough to decode dev num */
 596				__u64 mjr; /* major */
 597				__u64 mnr; /* minor */
 598				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 599				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 600				fattr->cf_rdev = MKDEV(mjr, mnr);
 601			} else if (bytes_read == 16) {
 602				/*
 603				 * Windows NFS server before Windows Server 2012
 604				 * stores major and minor number in SFU-modified
 605				 * style, just as 32-bit numbers. Recognize it.
 606				 */
 607				__u32 mjr; /* major */
 608				__u32 mnr; /* minor */
 609				mjr = le32_to_cpu(*(__le32 *)(pbuf+8));
 610				mnr = le32_to_cpu(*(__le32 *)(pbuf+12));
 611				fattr->cf_rdev = MKDEV(mjr, mnr);
 612			}
 613		} else if (memcmp("IntxCHR\0", pbuf, 8) == 0) {
 614			cifs_dbg(FYI, "Char device\n");
 615			fattr->cf_mode |= S_IFCHR;
 616			fattr->cf_dtype = DT_CHR;
 617			if (bytes_read == 24) {
 618				/* we have enough to decode dev num */
 619				__u64 mjr; /* major */
 620				__u64 mnr; /* minor */
 621				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 622				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 623				fattr->cf_rdev = MKDEV(mjr, mnr);
 624			} else if (bytes_read == 16) {
 625				/*
 626				 * Windows NFS server before Windows Server 2012
 627				 * stores major and minor number in SFU-modified
 628				 * style, just as 32-bit numbers. Recognize it.
 629				 */
 630				__u32 mjr; /* major */
 631				__u32 mnr; /* minor */
 632				mjr = le32_to_cpu(*(__le32 *)(pbuf+8));
 633				mnr = le32_to_cpu(*(__le32 *)(pbuf+12));
 634				fattr->cf_rdev = MKDEV(mjr, mnr);
 635			}
 636		} else if (memcmp("LnxSOCK", pbuf, 8) == 0) {
 637			cifs_dbg(FYI, "Socket\n");
 638			fattr->cf_mode |= S_IFSOCK;
 639			fattr->cf_dtype = DT_SOCK;
 640		} else if (memcmp("IntxLNK\1", pbuf, 8) == 0) {
 641			cifs_dbg(FYI, "Symlink\n");
 642			fattr->cf_mode |= S_IFLNK;
 643			fattr->cf_dtype = DT_LNK;
 644			if ((fattr->cf_eof > 8) && (fattr->cf_eof % 2 == 0)) {
 645				symlink_buf_utf16 = kmalloc(fattr->cf_eof-8 + 1, GFP_KERNEL);
 646				if (symlink_buf_utf16) {
 647					io_parms.offset = 8;
 648					io_parms.length = fattr->cf_eof-8 + 1;
 649					buf_type = CIFS_NO_BUFFER;
 650					rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
 651									       &symlink_len_utf16,
 652									       &symlink_buf_utf16,
 653									       &buf_type);
 654					/*
 655					 * Check that read buffer has valid length and does not
 656					 * contain UTF-16 null codepoint (via UniStrnlen() call)
 657					 * because Linux cannot process symlink with null byte.
 658					 */
 659					if ((rc == 0) &&
 660					    (symlink_len_utf16 > 0) &&
 661					    (symlink_len_utf16 < fattr->cf_eof-8 + 1) &&
 662					    (symlink_len_utf16 % 2 == 0) &&
 663					    (UniStrnlen((wchar_t *)symlink_buf_utf16, symlink_len_utf16/2) == symlink_len_utf16/2)) {
 664						fattr->cf_symlink_target =
 665							cifs_strndup_from_utf16(symlink_buf_utf16,
 666										symlink_len_utf16,
 667										true,
 668										cifs_sb->local_nls);
 669						if (!fattr->cf_symlink_target)
 670							rc = -ENOMEM;
 671					}
 672					kfree(symlink_buf_utf16);
 673				} else {
 674					rc = -ENOMEM;
 675				}
 676			}
 677		} else if (memcmp("LnxFIFO", pbuf, 8) == 0) {
 678			cifs_dbg(FYI, "FIFO\n");
 679			fattr->cf_mode |= S_IFIFO;
 680			fattr->cf_dtype = DT_FIFO;
 681		} else {
 682			fattr->cf_mode |= S_IFREG; /* file? */
 683			fattr->cf_dtype = DT_REG;
 684			rc = -EOPNOTSUPP;
 685		}
 686	} else if ((rc == 0) && (bytes_read == 1) && (pbuf[0] == '\0')) {
 687		cifs_dbg(FYI, "Socket\n");
 688		fattr->cf_mode |= S_IFSOCK;
 689		fattr->cf_dtype = DT_SOCK;
 690	} else {
 691		fattr->cf_mode |= S_IFREG; /* then it is a file */
 692		fattr->cf_dtype = DT_REG;
 693		rc = -EOPNOTSUPP; /* or some unknown SFU type */
 694	}
 695
 696	tcon->ses->server->ops->close(xid, tcon, &fid);
 697	cifs_put_tlink(tlink);
 698	return rc;
 699}
 700
 701#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
 702
 703/*
 704 * Fetch mode bits as provided by SFU.
 705 *
 706 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
 707 */
 708static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
 709			 struct cifs_sb_info *cifs_sb, unsigned int xid)
 710{
 711#ifdef CONFIG_CIFS_XATTR
 712	ssize_t rc;
 713	char ea_value[4];
 714	__u32 mode;
 715	struct tcon_link *tlink;
 716	struct cifs_tcon *tcon;
 717
 718	tlink = cifs_sb_tlink(cifs_sb);
 719	if (IS_ERR(tlink))
 720		return PTR_ERR(tlink);
 721	tcon = tlink_tcon(tlink);
 722
 723	if (tcon->ses->server->ops->query_all_EAs == NULL) {
 724		cifs_put_tlink(tlink);
 725		return -EOPNOTSUPP;
 726	}
 727
 728	rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
 729			"SETFILEBITS", ea_value, 4 /* size of buf */,
 730			cifs_sb);
 731	cifs_put_tlink(tlink);
 732	if (rc < 0)
 733		return (int)rc;
 734	else if (rc > 3) {
 735		mode = le32_to_cpu(*((__le32 *)ea_value));
 736		fattr->cf_mode &= ~SFBITS_MASK;
 737		cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
 738			 mode, fattr->cf_mode);
 739		fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
 740		cifs_dbg(FYI, "special mode bits 0%o\n", mode);
 741	}
 742
 743	return 0;
 744#else
 745	return -EOPNOTSUPP;
 746#endif
 747}
 748
 749#define POSIX_TYPE_FILE    0
 750#define POSIX_TYPE_DIR     1
 751#define POSIX_TYPE_SYMLINK 2
 752#define POSIX_TYPE_CHARDEV 3
 753#define POSIX_TYPE_BLKDEV  4
 754#define POSIX_TYPE_FIFO    5
 755#define POSIX_TYPE_SOCKET  6
 756
 757#define POSIX_X_OTH      0000001
 758#define POSIX_W_OTH      0000002
 759#define POSIX_R_OTH      0000004
 760#define POSIX_X_GRP      0000010
 761#define POSIX_W_GRP      0000020
 762#define POSIX_R_GRP      0000040
 763#define POSIX_X_USR      0000100
 764#define POSIX_W_USR      0000200
 765#define POSIX_R_USR      0000400
 766#define POSIX_STICKY     0001000
 767#define POSIX_SET_GID    0002000
 768#define POSIX_SET_UID    0004000
 769
 770#define POSIX_OTH_MASK      0000007
 771#define POSIX_GRP_MASK      0000070
 772#define POSIX_USR_MASK      0000700
 773#define POSIX_PERM_MASK     0000777
 774#define POSIX_FILETYPE_MASK 0070000
 775
 776#define POSIX_FILETYPE_SHIFT 12
 777
 778static u32 wire_perms_to_posix(u32 wire)
 779{
 780	u32 mode = 0;
 781
 782	mode |= (wire & POSIX_X_OTH) ? S_IXOTH : 0;
 783	mode |= (wire & POSIX_W_OTH) ? S_IWOTH : 0;
 784	mode |= (wire & POSIX_R_OTH) ? S_IROTH : 0;
 785	mode |= (wire & POSIX_X_GRP) ? S_IXGRP : 0;
 786	mode |= (wire & POSIX_W_GRP) ? S_IWGRP : 0;
 787	mode |= (wire & POSIX_R_GRP) ? S_IRGRP : 0;
 788	mode |= (wire & POSIX_X_USR) ? S_IXUSR : 0;
 789	mode |= (wire & POSIX_W_USR) ? S_IWUSR : 0;
 790	mode |= (wire & POSIX_R_USR) ? S_IRUSR : 0;
 791	mode |= (wire & POSIX_STICKY) ? S_ISVTX : 0;
 792	mode |= (wire & POSIX_SET_GID) ? S_ISGID : 0;
 793	mode |= (wire & POSIX_SET_UID) ? S_ISUID : 0;
 794
 795	return mode;
 796}
 797
 798static u32 posix_filetypes[] = {
 799	S_IFREG,
 800	S_IFDIR,
 801	S_IFLNK,
 802	S_IFCHR,
 803	S_IFBLK,
 804	S_IFIFO,
 805	S_IFSOCK
 806};
 807
 808static u32 wire_filetype_to_posix(u32 wire_type)
 809{
 810	if (wire_type >= ARRAY_SIZE(posix_filetypes)) {
 811		pr_warn("Unexpected type %u", wire_type);
 812		return 0;
 813	}
 814	return posix_filetypes[wire_type];
 815}
 816
 817umode_t wire_mode_to_posix(u32 wire, bool is_dir)
 818{
 819	u32 wire_type;
 820	u32 mode;
 821
 822	wire_type = (wire & POSIX_FILETYPE_MASK) >> POSIX_FILETYPE_SHIFT;
 823	/* older servers do not set POSIX file type in the mode field in the response */
 824	if ((wire_type == 0) && is_dir)
 825		mode = wire_perms_to_posix(wire) | S_IFDIR;
 826	else
 827		mode = (wire_perms_to_posix(wire) | wire_filetype_to_posix(wire_type));
 828	return (umode_t)mode;
 829}
 830
 831/* Fill a cifs_fattr struct with info from POSIX info struct */
 832static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr,
 833				       struct cifs_open_info_data *data,
 834				       struct super_block *sb)
 835{
 836	struct smb311_posix_qinfo *info = &data->posix_fi;
 837	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 838	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 839
 840	memset(fattr, 0, sizeof(*fattr));
 841
 842	/* no fattr->flags to set */
 843	fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
 844	fattr->cf_uniqueid = le64_to_cpu(info->Inode);
 845
 846	if (info->LastAccessTime)
 847		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 848	else
 849		ktime_get_coarse_real_ts64(&fattr->cf_atime);
 850
 851	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 852	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
 853
 854	if (data->adjust_tz) {
 855		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
 856		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
 857	}
 858
 859	/*
 860	 * The srv fs device id is overridden on network mount so setting
 861	 * @fattr->cf_rdev isn't needed here.
 862	 */
 863	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 864	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
 865	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
 866	fattr->cf_nlink = le32_to_cpu(info->HardLinks);
 867	fattr->cf_mode = wire_mode_to_posix(le32_to_cpu(info->Mode),
 868					    fattr->cf_cifsattrs & ATTR_DIRECTORY);
 869
 870	if (cifs_open_data_reparse(data) &&
 871	    cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
 872		goto out_reparse;
 873
 874	fattr->cf_dtype = S_DT(fattr->cf_mode);
 875
 876out_reparse:
 877	if (S_ISLNK(fattr->cf_mode)) {
 878		if (likely(data->symlink_target))
 879			fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
 880		fattr->cf_symlink_target = data->symlink_target;
 881		data->symlink_target = NULL;
 882	}
 883	sid_to_id(cifs_sb, &data->posix_owner, fattr, SIDOWNER);
 884	sid_to_id(cifs_sb, &data->posix_group, fattr, SIDGROUP);
 885
 886	cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
 887		fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
 888}
 889
 890static void cifs_open_info_to_fattr(struct cifs_fattr *fattr,
 891				    struct cifs_open_info_data *data,
 892				    struct super_block *sb)
 893{
 894	struct smb2_file_all_info *info = &data->fi;
 895	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 896	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 897
 898	memset(fattr, 0, sizeof(*fattr));
 899	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
 900	if (info->DeletePending)
 901		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
 902
 903	if (info->LastAccessTime)
 904		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 905	else
 906		ktime_get_coarse_real_ts64(&fattr->cf_atime);
 907
 908	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 909	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
 910
 911	if (data->adjust_tz) {
 912		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
 913		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
 914	}
 915
 916	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 917	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
 918	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
 919	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
 920	fattr->cf_uid = cifs_sb->ctx->linux_uid;
 921	fattr->cf_gid = cifs_sb->ctx->linux_gid;
 922
 923	fattr->cf_mode = cifs_sb->ctx->file_mode;
 924	if (cifs_open_data_reparse(data) &&
 925	    cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
 926		goto out_reparse;
 927
 928	if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
 929		fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
 930		fattr->cf_dtype = DT_DIR;
 931		/*
 932		 * Server can return wrong NumberOfLinks value for directories
 933		 * when Unix extensions are disabled - fake it.
 934		 */
 935		if (!tcon->unix_ext)
 936			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 937	} else {
 938		fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
 939		fattr->cf_dtype = DT_REG;
 940
 941		/*
 942		 * Don't accept zero nlink from non-unix servers unless
 943		 * delete is pending.  Instead mark it as unknown.
 944		 */
 945		if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
 946		    !info->DeletePending) {
 947			cifs_dbg(VFS, "bogus file nlink value %u\n",
 948				 fattr->cf_nlink);
 949			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 950		}
 951	}
 952
 953	/* clear write bits if ATTR_READONLY is set */
 954	if (fattr->cf_cifsattrs & ATTR_READONLY)
 955		fattr->cf_mode &= ~(S_IWUGO);
 956
 957out_reparse:
 958	if (S_ISLNK(fattr->cf_mode)) {
 959		if (likely(data->symlink_target))
 960			fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
 961		fattr->cf_symlink_target = data->symlink_target;
 962		data->symlink_target = NULL;
 963	}
 964}
 965
 966static int
 967cifs_get_file_info(struct file *filp)
 968{
 969	int rc;
 970	unsigned int xid;
 971	struct cifs_open_info_data data = {};
 972	struct cifs_fattr fattr;
 973	struct inode *inode = file_inode(filp);
 974	struct cifsFileInfo *cfile = filp->private_data;
 975	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 976	struct TCP_Server_Info *server = tcon->ses->server;
 977	struct dentry *dentry = filp->f_path.dentry;
 978	void *page = alloc_dentry_path();
 979	const unsigned char *path;
 980
 981	if (!server->ops->query_file_info) {
 982		free_dentry_path(page);
 983		return -ENOSYS;
 984	}
 985
 986	xid = get_xid();
 987	rc = server->ops->query_file_info(xid, tcon, cfile, &data);
 988	switch (rc) {
 989	case 0:
 990		/* TODO: add support to query reparse tag */
 991		data.adjust_tz = false;
 992		if (data.symlink_target) {
 993			data.reparse_point = true;
 994			data.reparse.tag = IO_REPARSE_TAG_SYMLINK;
 995		}
 996		path = build_path_from_dentry(dentry, page);
 997		if (IS_ERR(path)) {
 998			rc = PTR_ERR(path);
 999			goto cgfi_exit;
1000		}
1001		cifs_open_info_to_fattr(&fattr, &data, inode->i_sb);
1002		if (fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1003			cifs_mark_open_handles_for_deleted_file(inode, path);
1004		break;
1005	case -EREMOTE:
1006		cifs_create_junction_fattr(&fattr, inode->i_sb);
1007		break;
1008	case -EOPNOTSUPP:
1009	case -EINVAL:
1010		/*
1011		 * FIXME: legacy server -- fall back to path-based call?
1012		 * for now, just skip revalidating and mark inode for
1013		 * immediate reval.
1014		 */
1015		rc = 0;
1016		CIFS_I(inode)->time = 0;
1017		goto cgfi_exit;
1018	default:
1019		goto cgfi_exit;
1020	}
1021
1022	/*
1023	 * don't bother with SFU junk here -- just mark inode as needing
1024	 * revalidation.
1025	 */
1026	fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
1027	fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
1028	/* if filetype is different, return error */
1029	rc = cifs_fattr_to_inode(inode, &fattr, false);
1030cgfi_exit:
1031	cifs_free_open_info(&data);
1032	free_dentry_path(page);
1033	free_xid(xid);
1034	return rc;
1035}
1036
1037/* Simple function to return a 64 bit hash of string.  Rarely called */
1038static __u64 simple_hashstr(const char *str)
1039{
1040	const __u64 hash_mult =  1125899906842597ULL; /* a big enough prime */
1041	__u64 hash = 0;
1042
1043	while (*str)
1044		hash = (hash + (__u64) *str++) * hash_mult;
1045
1046	return hash;
1047}
1048
1049#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1050/**
1051 * cifs_backup_query_path_info - SMB1 fallback code to get ino
1052 *
1053 * Fallback code to get file metadata when we don't have access to
1054 * full_path (EACCES) and have backup creds.
1055 *
1056 * @xid:	transaction id used to identify original request in logs
1057 * @tcon:	information about the server share we have mounted
1058 * @sb:	the superblock stores info such as disk space available
1059 * @full_path:	name of the file we are getting the metadata for
1060 * @resp_buf:	will be set to cifs resp buf and needs to be freed with
1061 * 		cifs_buf_release() when done with @data
1062 * @data:	will be set to search info result buffer
1063 */
1064static int
1065cifs_backup_query_path_info(int xid,
1066			    struct cifs_tcon *tcon,
1067			    struct super_block *sb,
1068			    const char *full_path,
1069			    void **resp_buf,
1070			    FILE_ALL_INFO **data)
1071{
1072	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1073	struct cifs_search_info info = {0};
1074	u16 flags;
1075	int rc;
1076
1077	*resp_buf = NULL;
1078	info.endOfSearch = false;
1079	if (tcon->unix_ext)
1080		info.info_level = SMB_FIND_FILE_UNIX;
1081	else if ((tcon->ses->capabilities &
1082		  tcon->ses->server->vals->cap_nt_find) == 0)
1083		info.info_level = SMB_FIND_FILE_INFO_STANDARD;
1084	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
1085		info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
1086	else /* no srvino useful for fallback to some netapp */
1087		info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
1088
1089	flags = CIFS_SEARCH_CLOSE_ALWAYS |
1090		CIFS_SEARCH_CLOSE_AT_END |
1091		CIFS_SEARCH_BACKUP_SEARCH;
1092
1093	rc = CIFSFindFirst(xid, tcon, full_path,
1094			   cifs_sb, NULL, flags, &info, false);
1095	if (rc)
1096		return rc;
1097
1098	*resp_buf = (void *)info.ntwrk_buf_start;
1099	*data = (FILE_ALL_INFO *)info.srch_entries_start;
1100	return 0;
1101}
1102#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1103
1104static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
1105			       struct inode **inode, const char *full_path,
1106			       struct cifs_open_info_data *data, struct cifs_fattr *fattr)
1107{
1108	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1109	struct TCP_Server_Info *server = tcon->ses->server;
1110	int rc;
1111
1112	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
1113		if (*inode)
1114			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1115		else
1116			fattr->cf_uniqueid = iunique(sb, ROOT_I);
1117		return;
1118	}
1119
1120	/*
1121	 * If we have an inode pass a NULL tcon to ensure we don't
1122	 * make a round trip to the server. This only works for SMB2+.
1123	 */
1124	rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
1125				       &fattr->cf_uniqueid, data);
1126	if (rc) {
1127		/*
1128		 * If that fails reuse existing ino or generate one
1129		 * and disable server ones
1130		 */
1131		if (*inode)
1132			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1133		else {
1134			fattr->cf_uniqueid = iunique(sb, ROOT_I);
1135			cifs_autodisable_serverino(cifs_sb);
1136		}
1137		return;
1138	}
1139
1140	/* If no errors, check for zero root inode (invalid) */
1141	if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
1142		cifs_dbg(FYI, "Invalid (0) inodenum\n");
1143		if (*inode) {
1144			/* reuse */
1145			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
1146		} else {
1147			/* make an ino by hashing the UNC */
1148			fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
1149			fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
1150		}
1151	}
1152}
1153
1154static inline bool is_inode_cache_good(struct inode *ino)
1155{
1156	return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
1157}
1158
1159static int reparse_info_to_fattr(struct cifs_open_info_data *data,
1160				 struct super_block *sb,
1161				 const unsigned int xid,
1162				 struct cifs_tcon *tcon,
1163				 const char *full_path,
1164				 struct cifs_fattr *fattr)
1165{
1166	struct TCP_Server_Info *server = tcon->ses->server;
1167	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1168	struct kvec rsp_iov, *iov = NULL;
1169	int rsp_buftype = CIFS_NO_BUFFER;
1170	u32 tag = data->reparse.tag;
1171	int rc = 0;
1172
1173	if (!tag && server->ops->query_reparse_point) {
1174		rc = server->ops->query_reparse_point(xid, tcon, cifs_sb,
1175						      full_path, &tag,
1176						      &rsp_iov, &rsp_buftype);
1177		if (!rc)
1178			iov = &rsp_iov;
1179	} else if (data->reparse.io.buftype != CIFS_NO_BUFFER &&
1180		   data->reparse.io.iov.iov_base) {
1181		iov = &data->reparse.io.iov;
1182	}
1183
1184	rc = -EOPNOTSUPP;
1185	data->reparse.tag = tag;
1186	if (!data->reparse.tag) {
1187		if (server->ops->query_symlink) {
1188			rc = server->ops->query_symlink(xid, tcon,
1189							cifs_sb, full_path,
1190							&data->symlink_target);
1191		}
1192		if (rc == -EOPNOTSUPP)
1193			data->reparse.tag = IO_REPARSE_TAG_INTERNAL;
1194	}
1195
1196	switch (data->reparse.tag) {
1197	case 0: /* SMB1 symlink */
1198		break;
1199	case IO_REPARSE_TAG_INTERNAL:
1200		rc = 0;
1201		if (le32_to_cpu(data->fi.Attributes) & ATTR_DIRECTORY) {
1202			cifs_create_junction_fattr(fattr, sb);
1203			goto out;
1204		}
1205		break;
1206	case IO_REPARSE_TAG_MOUNT_POINT:
1207		cifs_create_junction_fattr(fattr, sb);
1208		rc = 0;
1209		goto out;
1210	default:
1211		/* Check for cached reparse point data */
1212		if (data->symlink_target || data->reparse.buf) {
1213			rc = 0;
1214		} else if (iov && server->ops->parse_reparse_point) {
1215			rc = server->ops->parse_reparse_point(cifs_sb,
1216							      full_path,
1217							      iov, data);
1218		}
1219		break;
1220	}
1221
1222	if (tcon->posix_extensions)
1223		smb311_posix_info_to_fattr(fattr, data, sb);
1224	else
1225		cifs_open_info_to_fattr(fattr, data, sb);
1226out:
1227	fattr->cf_cifstag = data->reparse.tag;
1228	free_rsp_buf(rsp_buftype, rsp_iov.iov_base);
1229	return rc;
1230}
1231
1232static int cifs_get_fattr(struct cifs_open_info_data *data,
1233			  struct super_block *sb, int xid,
1234			  const struct cifs_fid *fid,
1235			  struct cifs_fattr *fattr,
1236			  struct inode **inode,
1237			  const char *full_path)
1238{
1239	struct cifs_open_info_data tmp_data = {};
1240	struct cifs_tcon *tcon;
1241	struct TCP_Server_Info *server;
1242	struct tcon_link *tlink;
1243	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1244	void *smb1_backup_rsp_buf = NULL;
1245	int rc = 0;
1246	int tmprc = 0;
1247
1248	tlink = cifs_sb_tlink(cifs_sb);
1249	if (IS_ERR(tlink))
1250		return PTR_ERR(tlink);
1251	tcon = tlink_tcon(tlink);
1252	server = tcon->ses->server;
1253
1254	/*
1255	 * 1. Fetch file metadata if not provided (data)
1256	 */
1257
1258	if (!data) {
1259		rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1260						  full_path, &tmp_data);
1261		data = &tmp_data;
1262	}
1263
1264	/*
1265	 * 2. Convert it to internal cifs metadata (fattr)
1266	 */
1267
1268	switch (rc) {
1269	case 0:
1270		/*
1271		 * If the file is a reparse point, it is more complicated
1272		 * since we have to check if its reparse tag matches a known
1273		 * special file type e.g. symlink or fifo or char etc.
1274		 */
1275		if (cifs_open_data_reparse(data)) {
1276			rc = reparse_info_to_fattr(data, sb, xid, tcon,
1277						   full_path, fattr);
1278		} else {
1279			cifs_open_info_to_fattr(fattr, data, sb);
1280		}
1281		if (!rc && *inode &&
1282		    (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING))
1283			cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1284		break;
1285	case -EREMOTE:
1286		/* DFS link, no metadata available on this server */
1287		cifs_create_junction_fattr(fattr, sb);
1288		rc = 0;
1289		break;
1290	case -EACCES:
1291#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1292		/*
1293		 * perm errors, try again with backup flags if possible
1294		 *
1295		 * For SMB2 and later the backup intent flag
1296		 * is already sent if needed on open and there
1297		 * is no path based FindFirst operation to use
1298		 * to retry with
1299		 */
1300		if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1301			/* for easier reading */
1302			FILE_ALL_INFO *fi;
1303			FILE_DIRECTORY_INFO *fdi;
1304			SEARCH_ID_FULL_DIR_INFO *si;
1305
1306			rc = cifs_backup_query_path_info(xid, tcon, sb,
1307							 full_path,
1308							 &smb1_backup_rsp_buf,
1309							 &fi);
1310			if (rc)
1311				goto out;
1312
1313			move_cifs_info_to_smb2(&data->fi, fi);
1314			fdi = (FILE_DIRECTORY_INFO *)fi;
1315			si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1316
1317			cifs_dir_info_to_fattr(fattr, fdi, cifs_sb);
1318			fattr->cf_uniqueid = le64_to_cpu(si->UniqueId);
1319			/* uniqueid set, skip get inum step */
1320			goto handle_mnt_opt;
1321		} else {
1322			/* nothing we can do, bail out */
1323			goto out;
1324		}
1325#else
1326		goto out;
1327#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1328		break;
1329	default:
1330		cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1331		goto out;
1332	}
1333
1334	/*
1335	 * 3. Get or update inode number (fattr->cf_uniqueid)
1336	 */
1337
1338	cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, fattr);
1339
1340	/*
1341	 * 4. Tweak fattr based on mount options
1342	 */
1343#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1344handle_mnt_opt:
1345#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1346	/* query for SFU type info if supported and needed */
1347	if ((fattr->cf_cifsattrs & ATTR_SYSTEM) &&
1348	    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
1349		tmprc = cifs_sfu_type(fattr, full_path, cifs_sb, xid);
1350		if (tmprc)
1351			cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1352	}
1353
1354	/* fill in 0777 bits from ACL */
1355	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1356		rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1357				       true, full_path, fid);
1358		if (rc == -EREMOTE)
1359			rc = 0;
1360		if (rc) {
1361			cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1362				 __func__, rc);
1363			goto out;
1364		}
1365	} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1366		rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1367				       false, full_path, fid);
1368		if (rc == -EREMOTE)
1369			rc = 0;
1370		if (rc) {
1371			cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1372				 __func__, rc);
1373			goto out;
1374		}
1375	} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1376		/* fill in remaining high mode bits e.g. SUID, VTX */
1377		cifs_sfu_mode(fattr, full_path, cifs_sb, xid);
1378	else if (!(tcon->posix_extensions))
1379		/* clear write bits if ATTR_READONLY is set */
1380		if (fattr->cf_cifsattrs & ATTR_READONLY)
1381			fattr->cf_mode &= ~(S_IWUGO);
1382
1383
1384	/* check for Minshall+French symlinks */
1385	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1386		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1387		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1388	}
1389
1390out:
1391	cifs_buf_release(smb1_backup_rsp_buf);
1392	cifs_put_tlink(tlink);
1393	cifs_free_open_info(&tmp_data);
1394	return rc;
1395}
1396
1397int cifs_get_inode_info(struct inode **inode,
1398			const char *full_path,
1399			struct cifs_open_info_data *data,
1400			struct super_block *sb, int xid,
1401			const struct cifs_fid *fid)
1402{
1403	struct cifs_fattr fattr = {};
1404	int rc;
1405
1406	if (!data && is_inode_cache_good(*inode)) {
1407		cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1408		return 0;
1409	}
1410
1411	rc = cifs_get_fattr(data, sb, xid, fid, &fattr, inode, full_path);
1412	if (rc)
1413		goto out;
1414
1415	rc = update_inode_info(sb, &fattr, inode);
1416out:
1417	kfree(fattr.cf_symlink_target);
1418	return rc;
1419}
1420
1421static int smb311_posix_get_fattr(struct cifs_open_info_data *data,
1422				  struct cifs_fattr *fattr,
1423				  const char *full_path,
1424				  struct super_block *sb,
1425				  const unsigned int xid)
1426{
1427	struct cifs_open_info_data tmp_data = {};
1428	struct TCP_Server_Info *server;
1429	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1430	struct cifs_tcon *tcon;
1431	struct tcon_link *tlink;
1432	int tmprc;
1433	int rc = 0;
1434
1435	tlink = cifs_sb_tlink(cifs_sb);
1436	if (IS_ERR(tlink))
1437		return PTR_ERR(tlink);
1438	tcon = tlink_tcon(tlink);
1439	server = tcon->ses->server;
1440
1441	/*
1442	 * 1. Fetch file metadata if not provided (data)
1443	 */
1444	if (!data) {
1445		rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1446						  full_path, &tmp_data);
1447		data = &tmp_data;
1448	}
1449
1450	/*
1451	 * 2. Convert it to internal cifs metadata (fattr)
1452	 */
1453
1454	switch (rc) {
1455	case 0:
1456		if (cifs_open_data_reparse(data)) {
1457			rc = reparse_info_to_fattr(data, sb, xid, tcon,
1458						   full_path, fattr);
1459		} else {
1460			smb311_posix_info_to_fattr(fattr, data, sb);
1461		}
1462		break;
1463	case -EREMOTE:
1464		/* DFS link, no metadata available on this server */
1465		cifs_create_junction_fattr(fattr, sb);
1466		rc = 0;
1467		break;
1468	case -EACCES:
1469		/*
1470		 * For SMB2 and later the backup intent flag
1471		 * is already sent if needed on open and there
1472		 * is no path based FindFirst operation to use
1473		 * to retry with so nothing we can do, bail out
1474		 */
1475		goto out;
1476	default:
1477		cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1478		goto out;
1479	}
1480
1481	/*
1482	 * 3. Tweak fattr based on mount options
1483	 */
1484	/* check for Minshall+French symlinks */
1485	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1486		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1487		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1488	}
1489
1490out:
1491	cifs_put_tlink(tlink);
1492	cifs_free_open_info(data);
1493	return rc;
1494}
1495
1496int smb311_posix_get_inode_info(struct inode **inode,
1497				const char *full_path,
1498				struct cifs_open_info_data *data,
1499				struct super_block *sb,
1500				const unsigned int xid)
1501{
1502	struct cifs_fattr fattr = {};
1503	int rc;
1504
1505	if (!data && is_inode_cache_good(*inode)) {
1506		cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1507		return 0;
1508	}
1509
1510	rc = smb311_posix_get_fattr(data, &fattr, full_path, sb, xid);
1511	if (rc)
1512		goto out;
1513
1514	rc = update_inode_info(sb, &fattr, inode);
1515	if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1516		cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1517out:
1518	kfree(fattr.cf_symlink_target);
1519	return rc;
1520}
1521
1522static const struct inode_operations cifs_ipc_inode_ops = {
1523	.lookup = cifs_lookup,
1524};
1525
1526static int
1527cifs_find_inode(struct inode *inode, void *opaque)
1528{
1529	struct cifs_fattr *fattr = opaque;
1530
1531	/* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
1532
1533	/* don't match inode with different uniqueid */
1534	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1535		return 0;
1536
1537	/* use createtime like an i_generation field */
1538	if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1539		return 0;
1540
1541	/* don't match inode of different type */
1542	if (inode_wrong_type(inode, fattr->cf_mode))
1543		return 0;
1544
1545	/* if it's not a directory or has no dentries, then flag it */
1546	if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1547		fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1548
1549	return 1;
1550}
1551
1552static int
1553cifs_init_inode(struct inode *inode, void *opaque)
1554{
1555	struct cifs_fattr *fattr = opaque;
1556
1557	CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1558	CIFS_I(inode)->createtime = fattr->cf_createtime;
1559	return 0;
1560}
1561
1562/*
1563 * walk dentry list for an inode and report whether it has aliases that
1564 * are hashed. We use this to determine if a directory inode can actually
1565 * be used.
1566 */
1567static bool
1568inode_has_hashed_dentries(struct inode *inode)
1569{
1570	struct dentry *dentry;
1571
1572	spin_lock(&inode->i_lock);
1573	hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1574		if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1575			spin_unlock(&inode->i_lock);
1576			return true;
1577		}
1578	}
1579	spin_unlock(&inode->i_lock);
1580	return false;
1581}
1582
1583/* Given fattrs, get a corresponding inode */
1584struct inode *
1585cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1586{
1587	unsigned long hash;
1588	struct inode *inode;
1589
1590retry_iget5_locked:
1591	cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1592
1593	/* hash down to 32-bits on 32-bit arch */
1594	hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1595
1596	inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1597	if (inode) {
1598		/* was there a potentially problematic inode collision? */
1599		if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1600			fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1601
1602			if (inode_has_hashed_dentries(inode)) {
1603				cifs_autodisable_serverino(CIFS_SB(sb));
1604				iput(inode);
1605				fattr->cf_uniqueid = iunique(sb, ROOT_I);
1606				goto retry_iget5_locked;
1607			}
1608		}
1609
1610		/* can't fail - see cifs_find_inode() */
1611		cifs_fattr_to_inode(inode, fattr, false);
1612		if (sb->s_flags & SB_NOATIME)
1613			inode->i_flags |= S_NOATIME | S_NOCMTIME;
1614		if (inode->i_state & I_NEW) {
1615			inode->i_ino = hash;
1616			cifs_fscache_get_inode_cookie(inode);
1617			unlock_new_inode(inode);
1618		}
1619	}
1620
1621	return inode;
1622}
1623
1624/* gets root inode */
1625struct inode *cifs_root_iget(struct super_block *sb)
1626{
1627	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1628	struct cifs_fattr fattr = {};
1629	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1630	struct inode *inode = NULL;
1631	unsigned int xid;
1632	char *path = NULL;
1633	int len;
1634	int rc;
1635
1636	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1637	    && cifs_sb->prepath) {
1638		len = strlen(cifs_sb->prepath);
1639		path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1640		if (path == NULL)
1641			return ERR_PTR(-ENOMEM);
1642		path[0] = '/';
1643		memcpy(path+1, cifs_sb->prepath, len);
1644	} else {
1645		path = kstrdup("", GFP_KERNEL);
1646		if (path == NULL)
1647			return ERR_PTR(-ENOMEM);
1648	}
1649
1650	xid = get_xid();
1651	if (tcon->unix_ext) {
1652		rc = cifs_get_unix_fattr(path, sb, &fattr, &inode, xid);
1653		/* some servers mistakenly claim POSIX support */
1654		if (rc != -EOPNOTSUPP)
1655			goto iget_root;
1656		cifs_dbg(VFS, "server does not support POSIX extensions\n");
1657		tcon->unix_ext = false;
1658	}
1659
1660	convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1661	if (tcon->posix_extensions)
1662		rc = smb311_posix_get_fattr(NULL, &fattr, path, sb, xid);
1663	else
1664		rc = cifs_get_fattr(NULL, sb, xid, NULL, &fattr, &inode, path);
1665
1666iget_root:
1667	if (!rc) {
1668		if (fattr.cf_flags & CIFS_FATTR_JUNCTION) {
1669			fattr.cf_flags &= ~CIFS_FATTR_JUNCTION;
1670			cifs_autodisable_serverino(cifs_sb);
1671		}
1672		inode = cifs_iget(sb, &fattr);
1673	}
1674
1675	if (!inode) {
1676		inode = ERR_PTR(rc);
1677		goto out;
1678	}
1679
1680	if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1681		cifs_mark_open_handles_for_deleted_file(inode, path);
1682
1683	if (rc && tcon->pipe) {
1684		cifs_dbg(FYI, "ipc connection - fake read inode\n");
1685		spin_lock(&inode->i_lock);
1686		inode->i_mode |= S_IFDIR;
1687		set_nlink(inode, 2);
1688		inode->i_op = &cifs_ipc_inode_ops;
1689		inode->i_fop = &simple_dir_operations;
1690		inode->i_uid = cifs_sb->ctx->linux_uid;
1691		inode->i_gid = cifs_sb->ctx->linux_gid;
1692		spin_unlock(&inode->i_lock);
1693	} else if (rc) {
1694		iget_failed(inode);
1695		inode = ERR_PTR(rc);
1696	}
1697
1698out:
1699	kfree(path);
1700	free_xid(xid);
1701	kfree(fattr.cf_symlink_target);
1702	return inode;
1703}
1704
1705int
1706cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1707		   const char *full_path, __u32 dosattr)
1708{
1709	bool set_time = false;
1710	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1711	struct TCP_Server_Info *server;
1712	FILE_BASIC_INFO	info_buf;
1713
1714	if (attrs == NULL)
1715		return -EINVAL;
1716
1717	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1718	if (!server->ops->set_file_info)
1719		return -ENOSYS;
1720
1721	info_buf.Pad = 0;
1722
1723	if (attrs->ia_valid & ATTR_ATIME) {
1724		set_time = true;
1725		info_buf.LastAccessTime =
1726			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1727	} else
1728		info_buf.LastAccessTime = 0;
1729
1730	if (attrs->ia_valid & ATTR_MTIME) {
1731		set_time = true;
1732		info_buf.LastWriteTime =
1733		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1734	} else
1735		info_buf.LastWriteTime = 0;
1736
1737	/*
1738	 * Samba throws this field away, but windows may actually use it.
1739	 * Do not set ctime unless other time stamps are changed explicitly
1740	 * (i.e. by utimes()) since we would then have a mix of client and
1741	 * server times.
1742	 */
1743	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1744		cifs_dbg(FYI, "CIFS - CTIME changed\n");
1745		info_buf.ChangeTime =
1746		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1747	} else
1748		info_buf.ChangeTime = 0;
1749
1750	info_buf.CreationTime = 0;	/* don't change */
1751	info_buf.Attributes = cpu_to_le32(dosattr);
1752
1753	return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1754}
1755
1756#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1757/*
1758 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1759 * and rename it to a random name that hopefully won't conflict with
1760 * anything else.
1761 */
1762int
1763cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1764			   const unsigned int xid)
1765{
1766	int oplock = 0;
1767	int rc;
1768	struct cifs_fid fid;
1769	struct cifs_open_parms oparms;
1770	struct inode *inode = d_inode(dentry);
1771	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1772	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1773	struct tcon_link *tlink;
1774	struct cifs_tcon *tcon;
1775	__u32 dosattr, origattr;
1776	FILE_BASIC_INFO *info_buf = NULL;
1777
1778	tlink = cifs_sb_tlink(cifs_sb);
1779	if (IS_ERR(tlink))
1780		return PTR_ERR(tlink);
1781	tcon = tlink_tcon(tlink);
1782
1783	/*
1784	 * We cannot rename the file if the server doesn't support
1785	 * CAP_INFOLEVEL_PASSTHRU
1786	 */
1787	if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1788		rc = -EBUSY;
1789		goto out;
1790	}
1791
1792	oparms = (struct cifs_open_parms) {
1793		.tcon = tcon,
1794		.cifs_sb = cifs_sb,
1795		.desired_access = DELETE | FILE_WRITE_ATTRIBUTES,
1796		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
1797		.disposition = FILE_OPEN,
1798		.path = full_path,
1799		.fid = &fid,
1800	};
1801
1802	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1803	if (rc != 0)
1804		goto out;
1805
1806	origattr = cifsInode->cifsAttrs;
1807	if (origattr == 0)
1808		origattr |= ATTR_NORMAL;
1809
1810	dosattr = origattr & ~ATTR_READONLY;
1811	if (dosattr == 0)
1812		dosattr |= ATTR_NORMAL;
1813	dosattr |= ATTR_HIDDEN;
1814
1815	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1816	if (dosattr != origattr) {
1817		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1818		if (info_buf == NULL) {
1819			rc = -ENOMEM;
1820			goto out_close;
1821		}
1822		info_buf->Attributes = cpu_to_le32(dosattr);
1823		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1824					current->tgid);
1825		/* although we would like to mark the file hidden
1826 		   if that fails we will still try to rename it */
1827		if (!rc)
1828			cifsInode->cifsAttrs = dosattr;
1829		else
1830			dosattr = origattr; /* since not able to change them */
1831	}
1832
1833	/* rename the file */
1834	rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1835				   cifs_sb->local_nls,
1836				   cifs_remap(cifs_sb));
1837	if (rc != 0) {
1838		rc = -EBUSY;
1839		goto undo_setattr;
1840	}
1841
1842	/* try to set DELETE_ON_CLOSE */
1843	if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1844		rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1845					       current->tgid);
1846		/*
1847		 * some samba versions return -ENOENT when we try to set the
1848		 * file disposition here. Likely a samba bug, but work around
1849		 * it for now. This means that some cifsXXX files may hang
1850		 * around after they shouldn't.
1851		 *
1852		 * BB: remove this hack after more servers have the fix
1853		 */
1854		if (rc == -ENOENT)
1855			rc = 0;
1856		else if (rc != 0) {
1857			rc = -EBUSY;
1858			goto undo_rename;
1859		}
1860		set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1861	}
1862
1863out_close:
1864	CIFSSMBClose(xid, tcon, fid.netfid);
1865out:
1866	kfree(info_buf);
1867	cifs_put_tlink(tlink);
1868	return rc;
1869
1870	/*
1871	 * reset everything back to the original state. Don't bother
1872	 * dealing with errors here since we can't do anything about
1873	 * them anyway.
1874	 */
1875undo_rename:
1876	CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1877				cifs_sb->local_nls, cifs_remap(cifs_sb));
1878undo_setattr:
1879	if (dosattr != origattr) {
1880		info_buf->Attributes = cpu_to_le32(origattr);
1881		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1882					current->tgid))
1883			cifsInode->cifsAttrs = origattr;
1884	}
1885
1886	goto out_close;
1887}
1888#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1889
1890/* copied from fs/nfs/dir.c with small changes */
1891static void
1892cifs_drop_nlink(struct inode *inode)
1893{
1894	spin_lock(&inode->i_lock);
1895	if (inode->i_nlink > 0)
1896		drop_nlink(inode);
1897	spin_unlock(&inode->i_lock);
1898}
1899
1900/*
1901 * If d_inode(dentry) is null (usually meaning the cached dentry
1902 * is a negative dentry) then we would attempt a standard SMB delete, but
1903 * if that fails we can not attempt the fall back mechanisms on EACCES
1904 * but will return the EACCES to the caller. Note that the VFS does not call
1905 * unlink on negative dentries currently.
1906 */
1907int cifs_unlink(struct inode *dir, struct dentry *dentry)
1908{
1909	int rc = 0;
1910	unsigned int xid;
1911	const char *full_path;
1912	void *page;
1913	struct inode *inode = d_inode(dentry);
1914	struct cifsInodeInfo *cifs_inode;
1915	struct super_block *sb = dir->i_sb;
1916	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1917	struct tcon_link *tlink;
1918	struct cifs_tcon *tcon;
1919	struct TCP_Server_Info *server;
1920	struct iattr *attrs = NULL;
1921	__u32 dosattr = 0, origattr = 0;
1922
1923	cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1924
1925	if (unlikely(cifs_forced_shutdown(cifs_sb)))
1926		return -EIO;
1927
1928	tlink = cifs_sb_tlink(cifs_sb);
1929	if (IS_ERR(tlink))
1930		return PTR_ERR(tlink);
1931	tcon = tlink_tcon(tlink);
1932	server = tcon->ses->server;
1933
1934	xid = get_xid();
1935	page = alloc_dentry_path();
1936
1937	if (tcon->nodelete) {
1938		rc = -EACCES;
1939		goto unlink_out;
1940	}
1941
1942	/* Unlink can be called from rename so we can not take the
1943	 * sb->s_vfs_rename_mutex here */
1944	full_path = build_path_from_dentry(dentry, page);
1945	if (IS_ERR(full_path)) {
1946		rc = PTR_ERR(full_path);
1947		goto unlink_out;
1948	}
1949
1950	netfs_wait_for_outstanding_io(inode);
1951	cifs_close_deferred_file_under_dentry(tcon, full_path);
1952#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1953	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1954				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1955		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1956			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1957			cifs_remap(cifs_sb));
1958		cifs_dbg(FYI, "posix del rc %d\n", rc);
1959		if ((rc == 0) || (rc == -ENOENT))
1960			goto psx_del_no_retry;
1961	}
1962#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1963
1964retry_std_delete:
1965	if (!server->ops->unlink) {
1966		rc = -ENOSYS;
1967		goto psx_del_no_retry;
1968	}
1969
1970	rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry);
1971
1972psx_del_no_retry:
1973	if (!rc) {
1974		if (inode) {
1975			cifs_mark_open_handles_for_deleted_file(inode, full_path);
1976			cifs_drop_nlink(inode);
1977		}
1978	} else if (rc == -ENOENT) {
1979		d_drop(dentry);
1980	} else if (rc == -EBUSY) {
1981		if (server->ops->rename_pending_delete) {
1982			rc = server->ops->rename_pending_delete(full_path,
1983								dentry, xid);
1984			if (rc == 0) {
1985				cifs_mark_open_handles_for_deleted_file(inode, full_path);
1986				cifs_drop_nlink(inode);
1987			}
1988		}
1989	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1990		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1991		if (attrs == NULL) {
1992			rc = -ENOMEM;
1993			goto out_reval;
1994		}
1995
1996		/* try to reset dos attributes */
1997		cifs_inode = CIFS_I(inode);
1998		origattr = cifs_inode->cifsAttrs;
1999		if (origattr == 0)
2000			origattr |= ATTR_NORMAL;
2001		dosattr = origattr & ~ATTR_READONLY;
2002		if (dosattr == 0)
2003			dosattr |= ATTR_NORMAL;
2004		dosattr |= ATTR_HIDDEN;
2005
2006		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2007		if (rc != 0)
2008			goto out_reval;
2009
2010		goto retry_std_delete;
2011	}
2012
2013	/* undo the setattr if we errored out and it's needed */
2014	if (rc != 0 && dosattr != 0)
2015		cifs_set_file_info(inode, attrs, xid, full_path, origattr);
2016
2017out_reval:
2018	if (inode) {
2019		cifs_inode = CIFS_I(inode);
2020		cifs_inode->time = 0;	/* will force revalidate to get info
2021					   when needed */
2022		inode_set_ctime_current(inode);
2023	}
2024	inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
2025	cifs_inode = CIFS_I(dir);
2026	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */
2027unlink_out:
2028	free_dentry_path(page);
2029	kfree(attrs);
2030	free_xid(xid);
2031	cifs_put_tlink(tlink);
2032	return rc;
2033}
2034
2035static int
2036cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
2037		 const char *full_path, struct cifs_sb_info *cifs_sb,
2038		 struct cifs_tcon *tcon, const unsigned int xid)
2039{
2040	int rc = 0;
2041	struct inode *inode = NULL;
2042
2043	if (tcon->posix_extensions) {
2044		rc = smb311_posix_get_inode_info(&inode, full_path,
2045						 NULL, parent->i_sb, xid);
2046#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2047	} else if (tcon->unix_ext) {
2048		rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
2049					      xid);
2050#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2051	} else {
2052		rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
2053					 xid, NULL);
2054	}
2055
2056	if (rc)
2057		return rc;
2058
2059	if (!S_ISDIR(inode->i_mode)) {
2060		/*
2061		 * mkdir succeeded, but another client has managed to remove the
2062		 * sucker and replace it with non-directory.  Return success,
2063		 * but don't leave the child in dcache.
2064		 */
2065		 iput(inode);
2066		 d_drop(dentry);
2067		 return 0;
2068	}
2069	/*
2070	 * setting nlink not necessary except in cases where we failed to get it
2071	 * from the server or was set bogus. Also, since this is a brand new
2072	 * inode, no need to grab the i_lock before setting the i_nlink.
2073	 */
2074	if (inode->i_nlink < 2)
2075		set_nlink(inode, 2);
2076	mode &= ~current_umask();
2077	/* must turn on setgid bit if parent dir has it */
2078	if (parent->i_mode & S_ISGID)
2079		mode |= S_ISGID;
2080
2081#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2082	if (tcon->unix_ext) {
2083		struct cifs_unix_set_info_args args = {
2084			.mode	= mode,
2085			.ctime	= NO_CHANGE_64,
2086			.atime	= NO_CHANGE_64,
2087			.mtime	= NO_CHANGE_64,
2088			.device	= 0,
2089		};
2090		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2091			args.uid = current_fsuid();
2092			if (parent->i_mode & S_ISGID)
2093				args.gid = parent->i_gid;
2094			else
2095				args.gid = current_fsgid();
2096		} else {
2097			args.uid = INVALID_UID; /* no change */
2098			args.gid = INVALID_GID; /* no change */
2099		}
2100		CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
2101				       cifs_sb->local_nls,
2102				       cifs_remap(cifs_sb));
2103	} else {
2104#else
2105	{
2106#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2107		struct TCP_Server_Info *server = tcon->ses->server;
2108		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2109		    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
2110			server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
2111						   tcon, xid);
2112		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
2113			inode->i_mode = (mode | S_IFDIR);
2114
2115		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
2116			inode->i_uid = current_fsuid();
2117			if (inode->i_mode & S_ISGID)
2118				inode->i_gid = parent->i_gid;
2119			else
2120				inode->i_gid = current_fsgid();
2121		}
2122	}
2123	d_instantiate(dentry, inode);
2124	return 0;
2125}
2126
2127#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2128static int
2129cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
2130		 const char *full_path, struct cifs_sb_info *cifs_sb,
2131		 struct cifs_tcon *tcon, const unsigned int xid)
2132{
2133	int rc = 0;
2134	u32 oplock = 0;
2135	FILE_UNIX_BASIC_INFO *info = NULL;
2136	struct inode *newinode = NULL;
2137	struct cifs_fattr fattr;
2138
2139	info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
2140	if (info == NULL) {
2141		rc = -ENOMEM;
2142		goto posix_mkdir_out;
2143	}
2144
2145	mode &= ~current_umask();
2146	rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
2147			     NULL /* netfid */, info, &oplock, full_path,
2148			     cifs_sb->local_nls, cifs_remap(cifs_sb));
2149	if (rc == -EOPNOTSUPP)
2150		goto posix_mkdir_out;
2151	else if (rc) {
2152		cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
2153		d_drop(dentry);
2154		goto posix_mkdir_out;
2155	}
2156
2157	if (info->Type == cpu_to_le32(-1))
2158		/* no return info, go query for it */
2159		goto posix_mkdir_get_info;
2160	/*
2161	 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
2162	 * need to set uid/gid.
2163	 */
2164
2165	cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
2166	cifs_fill_uniqueid(inode->i_sb, &fattr);
2167	newinode = cifs_iget(inode->i_sb, &fattr);
2168	if (!newinode)
2169		goto posix_mkdir_get_info;
2170
2171	d_instantiate(dentry, newinode);
2172
2173#ifdef CONFIG_CIFS_DEBUG2
2174	cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
2175		 dentry, dentry, newinode);
2176
2177	if (newinode->i_nlink != 2)
2178		cifs_dbg(FYI, "unexpected number of links %d\n",
2179			 newinode->i_nlink);
2180#endif
2181
2182posix_mkdir_out:
2183	kfree(info);
2184	return rc;
2185posix_mkdir_get_info:
2186	rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
2187			      xid);
2188	goto posix_mkdir_out;
2189}
2190#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2191
2192int cifs_mkdir(struct mnt_idmap *idmap, struct inode *inode,
2193	       struct dentry *direntry, umode_t mode)
2194{
2195	int rc = 0;
2196	unsigned int xid;
2197	struct cifs_sb_info *cifs_sb;
2198	struct tcon_link *tlink;
2199	struct cifs_tcon *tcon;
2200	struct TCP_Server_Info *server;
2201	const char *full_path;
2202	void *page;
2203
2204	cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
2205		 mode, inode);
2206
2207	cifs_sb = CIFS_SB(inode->i_sb);
2208	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2209		return -EIO;
2210	tlink = cifs_sb_tlink(cifs_sb);
2211	if (IS_ERR(tlink))
2212		return PTR_ERR(tlink);
2213	tcon = tlink_tcon(tlink);
2214
2215	xid = get_xid();
2216
2217	page = alloc_dentry_path();
2218	full_path = build_path_from_dentry(direntry, page);
2219	if (IS_ERR(full_path)) {
2220		rc = PTR_ERR(full_path);
2221		goto mkdir_out;
2222	}
2223
2224	server = tcon->ses->server;
2225
2226	if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
2227		rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
2228					      cifs_sb);
2229		d_drop(direntry); /* for time being always refresh inode info */
2230		goto mkdir_out;
2231	}
2232
2233#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2234	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
2235				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
2236		rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
2237				      tcon, xid);
2238		if (rc != -EOPNOTSUPP)
2239			goto mkdir_out;
2240	}
2241#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2242
2243	if (!server->ops->mkdir) {
2244		rc = -ENOSYS;
2245		goto mkdir_out;
2246	}
2247
2248	/* BB add setting the equivalent of mode via CreateX w/ACLs */
2249	rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
2250	if (rc) {
2251		cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
2252		d_drop(direntry);
2253		goto mkdir_out;
2254	}
2255
2256	/* TODO: skip this for smb2/smb3 */
2257	rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
2258			      xid);
2259mkdir_out:
2260	/*
2261	 * Force revalidate to get parent dir info when needed since cached
2262	 * attributes are invalid now.
2263	 */
2264	CIFS_I(inode)->time = 0;
2265	free_dentry_path(page);
2266	free_xid(xid);
2267	cifs_put_tlink(tlink);
2268	return rc;
2269}
2270
2271int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2272{
2273	int rc = 0;
2274	unsigned int xid;
2275	struct cifs_sb_info *cifs_sb;
2276	struct tcon_link *tlink;
2277	struct cifs_tcon *tcon;
2278	struct TCP_Server_Info *server;
2279	const char *full_path;
2280	void *page = alloc_dentry_path();
2281	struct cifsInodeInfo *cifsInode;
2282
2283	cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2284
2285	xid = get_xid();
2286
2287	full_path = build_path_from_dentry(direntry, page);
2288	if (IS_ERR(full_path)) {
2289		rc = PTR_ERR(full_path);
2290		goto rmdir_exit;
2291	}
2292
2293	cifs_sb = CIFS_SB(inode->i_sb);
2294	if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2295		rc = -EIO;
2296		goto rmdir_exit;
2297	}
2298
2299	tlink = cifs_sb_tlink(cifs_sb);
2300	if (IS_ERR(tlink)) {
2301		rc = PTR_ERR(tlink);
2302		goto rmdir_exit;
2303	}
2304	tcon = tlink_tcon(tlink);
2305	server = tcon->ses->server;
2306
2307	if (!server->ops->rmdir) {
2308		rc = -ENOSYS;
2309		cifs_put_tlink(tlink);
2310		goto rmdir_exit;
2311	}
2312
2313	if (tcon->nodelete) {
2314		rc = -EACCES;
2315		cifs_put_tlink(tlink);
2316		goto rmdir_exit;
2317	}
2318
2319	rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2320	cifs_put_tlink(tlink);
2321
2322	if (!rc) {
2323		spin_lock(&d_inode(direntry)->i_lock);
2324		i_size_write(d_inode(direntry), 0);
2325		clear_nlink(d_inode(direntry));
2326		spin_unlock(&d_inode(direntry)->i_lock);
2327	}
2328
2329	cifsInode = CIFS_I(d_inode(direntry));
2330	/* force revalidate to go get info when needed */
2331	cifsInode->time = 0;
2332
2333	cifsInode = CIFS_I(inode);
2334	/*
2335	 * Force revalidate to get parent dir info when needed since cached
2336	 * attributes are invalid now.
2337	 */
2338	cifsInode->time = 0;
2339
2340	inode_set_ctime_current(d_inode(direntry));
2341	inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2342
2343rmdir_exit:
2344	free_dentry_path(page);
2345	free_xid(xid);
2346	return rc;
2347}
2348
2349static int
2350cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2351	       const char *from_path, struct dentry *to_dentry,
2352	       const char *to_path)
2353{
2354	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2355	struct tcon_link *tlink;
2356	struct cifs_tcon *tcon;
2357	struct TCP_Server_Info *server;
2358#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2359	struct cifs_fid fid;
2360	struct cifs_open_parms oparms;
2361	int oplock;
2362#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2363	int rc;
2364
2365	tlink = cifs_sb_tlink(cifs_sb);
2366	if (IS_ERR(tlink))
2367		return PTR_ERR(tlink);
2368	tcon = tlink_tcon(tlink);
2369	server = tcon->ses->server;
2370
2371	if (!server->ops->rename)
2372		return -ENOSYS;
2373
2374	/* try path-based rename first */
2375	rc = server->ops->rename(xid, tcon, from_dentry,
2376				 from_path, to_path, cifs_sb);
2377
2378	/*
2379	 * Don't bother with rename by filehandle unless file is busy and
2380	 * source. Note that cross directory moves do not work with
2381	 * rename by filehandle to various Windows servers.
2382	 */
2383	if (rc == 0 || rc != -EBUSY)
2384		goto do_rename_exit;
2385
2386	/* Don't fall back to using SMB on SMB 2+ mount */
2387	if (server->vals->protocol_id != 0)
2388		goto do_rename_exit;
2389
2390#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2391	/* open-file renames don't work across directories */
2392	if (to_dentry->d_parent != from_dentry->d_parent)
2393		goto do_rename_exit;
2394
2395	oparms = (struct cifs_open_parms) {
2396		.tcon = tcon,
2397		.cifs_sb = cifs_sb,
2398		/* open the file to be renamed -- we need DELETE perms */
2399		.desired_access = DELETE,
2400		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
2401		.disposition = FILE_OPEN,
2402		.path = from_path,
2403		.fid = &fid,
2404	};
2405
2406	rc = CIFS_open(xid, &oparms, &oplock, NULL);
2407	if (rc == 0) {
2408		rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2409				(const char *) to_dentry->d_name.name,
2410				cifs_sb->local_nls, cifs_remap(cifs_sb));
2411		CIFSSMBClose(xid, tcon, fid.netfid);
2412	}
2413#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2414do_rename_exit:
2415	if (rc == 0)
2416		d_move(from_dentry, to_dentry);
2417	cifs_put_tlink(tlink);
2418	return rc;
2419}
2420
2421int
2422cifs_rename2(struct mnt_idmap *idmap, struct inode *source_dir,
2423	     struct dentry *source_dentry, struct inode *target_dir,
2424	     struct dentry *target_dentry, unsigned int flags)
2425{
2426	const char *from_name, *to_name;
2427	void *page1, *page2;
2428	struct cifs_sb_info *cifs_sb;
2429	struct tcon_link *tlink;
2430	struct cifs_tcon *tcon;
2431	unsigned int xid;
2432	int rc, tmprc;
2433	int retry_count = 0;
2434	FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2435#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2436	FILE_UNIX_BASIC_INFO *info_buf_target;
2437#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2438
2439	if (flags & ~RENAME_NOREPLACE)
2440		return -EINVAL;
2441
2442	cifs_sb = CIFS_SB(source_dir->i_sb);
2443	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2444		return -EIO;
2445
2446	tlink = cifs_sb_tlink(cifs_sb);
2447	if (IS_ERR(tlink))
2448		return PTR_ERR(tlink);
2449	tcon = tlink_tcon(tlink);
2450
2451	page1 = alloc_dentry_path();
2452	page2 = alloc_dentry_path();
2453	xid = get_xid();
2454
2455	from_name = build_path_from_dentry(source_dentry, page1);
2456	if (IS_ERR(from_name)) {
2457		rc = PTR_ERR(from_name);
2458		goto cifs_rename_exit;
2459	}
2460
2461	to_name = build_path_from_dentry(target_dentry, page2);
2462	if (IS_ERR(to_name)) {
2463		rc = PTR_ERR(to_name);
2464		goto cifs_rename_exit;
2465	}
2466
2467	cifs_close_deferred_file_under_dentry(tcon, from_name);
2468	if (d_inode(target_dentry) != NULL) {
2469		netfs_wait_for_outstanding_io(d_inode(target_dentry));
2470		cifs_close_deferred_file_under_dentry(tcon, to_name);
2471	}
2472
2473	rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2474			    to_name);
2475
2476	if (rc == -EACCES) {
2477		while (retry_count < 3) {
2478			cifs_close_all_deferred_files(tcon);
2479			rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2480					    to_name);
2481			if (rc != -EACCES)
2482				break;
2483			retry_count++;
2484		}
2485	}
2486
2487	/*
2488	 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2489	 */
2490	if (flags & RENAME_NOREPLACE)
2491		goto cifs_rename_exit;
2492
2493#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2494	if (rc == -EEXIST && tcon->unix_ext) {
2495		/*
2496		 * Are src and dst hardlinks of same inode? We can only tell
2497		 * with unix extensions enabled.
2498		 */
2499		info_buf_source =
2500			kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2501					GFP_KERNEL);
2502		if (info_buf_source == NULL) {
2503			rc = -ENOMEM;
2504			goto cifs_rename_exit;
2505		}
2506
2507		info_buf_target = info_buf_source + 1;
2508		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2509					     info_buf_source,
2510					     cifs_sb->local_nls,
2511					     cifs_remap(cifs_sb));
2512		if (tmprc != 0)
2513			goto unlink_target;
2514
2515		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2516					     info_buf_target,
2517					     cifs_sb->local_nls,
2518					     cifs_remap(cifs_sb));
2519
2520		if (tmprc == 0 && (info_buf_source->UniqueId ==
2521				   info_buf_target->UniqueId)) {
2522			/* same file, POSIX says that this is a noop */
2523			rc = 0;
2524			goto cifs_rename_exit;
2525		}
2526	}
2527	/*
2528	 * else ... BB we could add the same check for Windows by
2529	 * checking the UniqueId via FILE_INTERNAL_INFO
2530	 */
2531
2532unlink_target:
2533#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2534
2535	/* Try unlinking the target dentry if it's not negative */
2536	if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2537		if (d_is_dir(target_dentry))
2538			tmprc = cifs_rmdir(target_dir, target_dentry);
2539		else
2540			tmprc = cifs_unlink(target_dir, target_dentry);
2541		if (tmprc)
2542			goto cifs_rename_exit;
2543		rc = cifs_do_rename(xid, source_dentry, from_name,
2544				    target_dentry, to_name);
2545	}
2546
2547	/* force revalidate to go get info when needed */
2548	CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2549
2550cifs_rename_exit:
2551	kfree(info_buf_source);
2552	free_dentry_path(page2);
2553	free_dentry_path(page1);
2554	free_xid(xid);
2555	cifs_put_tlink(tlink);
2556	return rc;
2557}
2558
2559static bool
2560cifs_dentry_needs_reval(struct dentry *dentry)
2561{
2562	struct inode *inode = d_inode(dentry);
2563	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2564	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2565	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2566	struct cached_fid *cfid = NULL;
2567
2568	if (cifs_i->time == 0)
2569		return true;
2570
2571	if (CIFS_CACHE_READ(cifs_i))
2572		return false;
2573
2574	if (!lookupCacheEnabled)
2575		return true;
2576
2577	if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2578		if (cfid->time && cifs_i->time > cfid->time) {
2579			close_cached_dir(cfid);
2580			return false;
2581		}
2582		close_cached_dir(cfid);
2583	}
2584	/*
2585	 * depending on inode type, check if attribute caching disabled for
2586	 * files or directories
2587	 */
2588	if (S_ISDIR(inode->i_mode)) {
2589		if (!cifs_sb->ctx->acdirmax)
2590			return true;
2591		if (!time_in_range(jiffies, cifs_i->time,
2592				   cifs_i->time + cifs_sb->ctx->acdirmax))
2593			return true;
2594	} else { /* file */
2595		if (!cifs_sb->ctx->acregmax)
2596			return true;
2597		if (!time_in_range(jiffies, cifs_i->time,
2598				   cifs_i->time + cifs_sb->ctx->acregmax))
2599			return true;
2600	}
2601
2602	/* hardlinked files w/ noserverino get "special" treatment */
2603	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2604	    S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2605		return true;
2606
2607	return false;
2608}
2609
2610/**
2611 * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2612 *
2613 * @key:	currently unused
2614 * @mode:	the task state to sleep in
2615 */
2616static int
2617cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2618{
2619	schedule();
2620	if (signal_pending_state(mode, current))
2621		return -ERESTARTSYS;
2622	return 0;
2623}
2624
2625int
2626cifs_revalidate_mapping(struct inode *inode)
2627{
2628	int rc;
2629	struct cifsInodeInfo *cifs_inode = CIFS_I(inode);
2630	unsigned long *flags = &cifs_inode->flags;
2631	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2632
2633	/* swapfiles are not supposed to be shared */
2634	if (IS_SWAPFILE(inode))
2635		return 0;
2636
2637	rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2638				     TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2639	if (rc)
2640		return rc;
2641
2642	if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2643		/* for cache=singleclient, do not invalidate */
2644		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2645			goto skip_invalidate;
2646
2647		cifs_inode->netfs.zero_point = cifs_inode->netfs.remote_i_size;
2648		rc = filemap_invalidate_inode(inode, true, 0, LLONG_MAX);
2649		if (rc) {
2650			cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n",
2651				 __func__, inode, rc);
2652			set_bit(CIFS_INO_INVALID_MAPPING, flags);
2653		}
2654	}
2655
2656skip_invalidate:
2657	clear_bit_unlock(CIFS_INO_LOCK, flags);
2658	smp_mb__after_atomic();
2659	wake_up_bit(flags, CIFS_INO_LOCK);
2660
2661	return rc;
2662}
2663
2664int
2665cifs_zap_mapping(struct inode *inode)
2666{
2667	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2668	return cifs_revalidate_mapping(inode);
2669}
2670
2671int cifs_revalidate_file_attr(struct file *filp)
2672{
2673	int rc = 0;
2674	struct dentry *dentry = file_dentry(filp);
2675#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2676	struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2677#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2678
2679	if (!cifs_dentry_needs_reval(dentry))
2680		return rc;
2681
2682#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2683	if (tlink_tcon(cfile->tlink)->unix_ext)
2684		rc = cifs_get_file_info_unix(filp);
2685	else
2686#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2687		rc = cifs_get_file_info(filp);
2688
2689	return rc;
2690}
2691
2692int cifs_revalidate_dentry_attr(struct dentry *dentry)
2693{
2694	unsigned int xid;
2695	int rc = 0;
2696	struct inode *inode = d_inode(dentry);
2697	struct super_block *sb = dentry->d_sb;
2698	const char *full_path;
2699	void *page;
2700	int count = 0;
2701
2702	if (inode == NULL)
2703		return -ENOENT;
2704
2705	if (!cifs_dentry_needs_reval(dentry))
2706		return rc;
2707
2708	xid = get_xid();
2709
2710	page = alloc_dentry_path();
2711	full_path = build_path_from_dentry(dentry, page);
2712	if (IS_ERR(full_path)) {
2713		rc = PTR_ERR(full_path);
2714		goto out;
2715	}
2716
2717	cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2718		 full_path, inode, inode->i_count.counter,
2719		 dentry, cifs_get_time(dentry), jiffies);
2720
2721again:
2722	if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions) {
2723		rc = smb311_posix_get_inode_info(&inode, full_path,
2724						 NULL, sb, xid);
2725	} else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
2726		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2727	} else {
2728		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2729					 xid, NULL);
2730	}
2731	if (rc == -EAGAIN && count++ < 10)
2732		goto again;
2733out:
2734	free_dentry_path(page);
2735	free_xid(xid);
2736
2737	return rc;
2738}
2739
2740int cifs_revalidate_file(struct file *filp)
2741{
2742	int rc;
2743	struct inode *inode = file_inode(filp);
2744
2745	rc = cifs_revalidate_file_attr(filp);
2746	if (rc)
2747		return rc;
2748
2749	return cifs_revalidate_mapping(inode);
2750}
2751
2752/* revalidate a dentry's inode attributes */
2753int cifs_revalidate_dentry(struct dentry *dentry)
2754{
2755	int rc;
2756	struct inode *inode = d_inode(dentry);
2757
2758	rc = cifs_revalidate_dentry_attr(dentry);
2759	if (rc)
2760		return rc;
2761
2762	return cifs_revalidate_mapping(inode);
2763}
2764
2765int cifs_getattr(struct mnt_idmap *idmap, const struct path *path,
2766		 struct kstat *stat, u32 request_mask, unsigned int flags)
2767{
2768	struct dentry *dentry = path->dentry;
2769	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2770	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2771	struct inode *inode = d_inode(dentry);
2772	int rc;
2773
2774	if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2775		return -EIO;
2776
2777	/*
2778	 * We need to be sure that all dirty pages are written and the server
2779	 * has actual ctime, mtime and file length.
2780	 */
2781	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2782	    !CIFS_CACHE_READ(CIFS_I(inode)) &&
2783	    inode->i_mapping && inode->i_mapping->nrpages != 0) {
2784		rc = filemap_fdatawait(inode->i_mapping);
2785		if (rc) {
2786			mapping_set_error(inode->i_mapping, rc);
2787			return rc;
2788		}
2789	}
2790
2791	if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2792		CIFS_I(inode)->time = 0; /* force revalidate */
2793
2794	/*
2795	 * If the caller doesn't require syncing, only sync if
2796	 * necessary (e.g. due to earlier truncate or setattr
2797	 * invalidating the cached metadata)
2798	 */
2799	if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2800	    (CIFS_I(inode)->time == 0)) {
2801		rc = cifs_revalidate_dentry_attr(dentry);
2802		if (rc)
2803			return rc;
2804	}
2805
2806	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
2807	stat->blksize = cifs_sb->ctx->bsize;
2808	stat->ino = CIFS_I(inode)->uniqueid;
2809
2810	/* old CIFS Unix Extensions doesn't return create time */
2811	if (CIFS_I(inode)->createtime) {
2812		stat->result_mask |= STATX_BTIME;
2813		stat->btime =
2814		      cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2815	}
2816
2817	stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2818	if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2819		stat->attributes |= STATX_ATTR_COMPRESSED;
2820	if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2821		stat->attributes |= STATX_ATTR_ENCRYPTED;
2822
2823	/*
2824	 * If on a multiuser mount without unix extensions or cifsacl being
2825	 * enabled, and the admin hasn't overridden them, set the ownership
2826	 * to the fsuid/fsgid of the current process.
2827	 */
2828	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2829	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2830	    !tcon->unix_ext) {
2831		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2832			stat->uid = current_fsuid();
2833		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2834			stat->gid = current_fsgid();
2835	}
2836	return 0;
2837}
2838
2839int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2840		u64 len)
2841{
2842	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2843	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2844	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2845	struct TCP_Server_Info *server = tcon->ses->server;
2846	struct cifsFileInfo *cfile;
2847	int rc;
2848
2849	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2850		return -EIO;
2851
2852	/*
2853	 * We need to be sure that all dirty pages are written as they
2854	 * might fill holes on the server.
2855	 */
2856	if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2857	    inode->i_mapping->nrpages != 0) {
2858		rc = filemap_fdatawait(inode->i_mapping);
2859		if (rc) {
2860			mapping_set_error(inode->i_mapping, rc);
2861			return rc;
2862		}
2863	}
2864
2865	cfile = find_readable_file(cifs_i, false);
2866	if (cfile == NULL)
2867		return -EINVAL;
2868
2869	if (server->ops->fiemap) {
2870		rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2871		cifsFileInfo_put(cfile);
2872		return rc;
2873	}
2874
2875	cifsFileInfo_put(cfile);
2876	return -EOPNOTSUPP;
2877}
2878
2879int cifs_truncate_page(struct address_space *mapping, loff_t from)
2880{
2881	pgoff_t index = from >> PAGE_SHIFT;
2882	unsigned offset = from & (PAGE_SIZE - 1);
2883	struct page *page;
2884	int rc = 0;
2885
2886	page = grab_cache_page(mapping, index);
2887	if (!page)
2888		return -ENOMEM;
2889
2890	zero_user_segment(page, offset, PAGE_SIZE);
2891	unlock_page(page);
2892	put_page(page);
2893	return rc;
2894}
2895
2896void cifs_setsize(struct inode *inode, loff_t offset)
2897{
2898	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2899
2900	spin_lock(&inode->i_lock);
2901	i_size_write(inode, offset);
2902	spin_unlock(&inode->i_lock);
2903
2904	/* Cached inode must be refreshed on truncate */
2905	cifs_i->time = 0;
2906	truncate_pagecache(inode, offset);
2907}
2908
2909static int
2910cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2911		   unsigned int xid, const char *full_path, struct dentry *dentry)
2912{
2913	int rc;
2914	struct cifsFileInfo *open_file;
2915	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2916	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2917	struct tcon_link *tlink = NULL;
2918	struct cifs_tcon *tcon = NULL;
2919	struct TCP_Server_Info *server;
2920
2921	/*
2922	 * To avoid spurious oplock breaks from server, in the case of
2923	 * inodes that we already have open, avoid doing path based
2924	 * setting of file size if we can do it by handle.
2925	 * This keeps our caching token (oplock) and avoids timeouts
2926	 * when the local oplock break takes longer to flush
2927	 * writebehind data than the SMB timeout for the SetPathInfo
2928	 * request would allow
2929	 */
2930	open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2931	if (open_file) {
2932		tcon = tlink_tcon(open_file->tlink);
2933		server = tcon->ses->server;
2934		if (server->ops->set_file_size)
2935			rc = server->ops->set_file_size(xid, tcon, open_file,
2936							attrs->ia_size, false);
2937		else
2938			rc = -ENOSYS;
2939		cifsFileInfo_put(open_file);
2940		cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2941	} else
2942		rc = -EINVAL;
2943
2944	if (!rc)
2945		goto set_size_out;
2946
2947	if (tcon == NULL) {
2948		tlink = cifs_sb_tlink(cifs_sb);
2949		if (IS_ERR(tlink))
2950			return PTR_ERR(tlink);
2951		tcon = tlink_tcon(tlink);
2952		server = tcon->ses->server;
2953	}
2954
2955	/*
2956	 * Set file size by pathname rather than by handle either because no
2957	 * valid, writeable file handle for it was found or because there was
2958	 * an error setting it by handle.
2959	 */
2960	if (server->ops->set_path_size)
2961		rc = server->ops->set_path_size(xid, tcon, full_path,
2962						attrs->ia_size, cifs_sb, false, dentry);
2963	else
2964		rc = -ENOSYS;
2965	cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2966
2967	if (tlink)
2968		cifs_put_tlink(tlink);
2969
2970set_size_out:
2971	if (rc == 0) {
2972		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
2973		cifs_setsize(inode, attrs->ia_size);
2974		/*
2975		 * i_blocks is not related to (i_size / i_blksize), but instead
2976		 * 512 byte (2**9) size is required for calculating num blocks.
2977		 * Until we can query the server for actual allocation size,
2978		 * this is best estimate we have for blocks allocated for a file
2979		 * Number of blocks must be rounded up so size 1 is not 0 blocks
2980		 */
2981		inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2982
2983		/*
2984		 * The man page of truncate says if the size changed,
2985		 * then the st_ctime and st_mtime fields for the file
2986		 * are updated.
2987		 */
2988		attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2989		attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2990
2991		cifs_truncate_page(inode->i_mapping, inode->i_size);
2992	}
2993
2994	return rc;
2995}
2996
2997#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2998static int
2999cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
3000{
3001	int rc;
3002	unsigned int xid;
3003	const char *full_path;
3004	void *page = alloc_dentry_path();
3005	struct inode *inode = d_inode(direntry);
3006	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3007	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3008	struct tcon_link *tlink;
3009	struct cifs_tcon *pTcon;
3010	struct cifs_unix_set_info_args *args = NULL;
3011	struct cifsFileInfo *open_file;
3012
3013	cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
3014		 direntry, attrs->ia_valid);
3015
3016	xid = get_xid();
3017
3018	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3019		attrs->ia_valid |= ATTR_FORCE;
3020
3021	rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3022	if (rc < 0)
3023		goto out;
3024
3025	full_path = build_path_from_dentry(direntry, page);
3026	if (IS_ERR(full_path)) {
3027		rc = PTR_ERR(full_path);
3028		goto out;
3029	}
3030
3031	/*
3032	 * Attempt to flush data before changing attributes. We need to do
3033	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
3034	 * ownership or mode then we may also need to do this. Here, we take
3035	 * the safe way out and just do the flush on all setattr requests. If
3036	 * the flush returns error, store it to report later and continue.
3037	 *
3038	 * BB: This should be smarter. Why bother flushing pages that
3039	 * will be truncated anyway? Also, should we error out here if
3040	 * the flush returns error?
3041	 */
3042	rc = filemap_write_and_wait(inode->i_mapping);
3043	if (is_interrupt_error(rc)) {
3044		rc = -ERESTARTSYS;
3045		goto out;
3046	}
3047
3048	mapping_set_error(inode->i_mapping, rc);
3049	rc = 0;
3050
3051	if (attrs->ia_valid & ATTR_SIZE) {
3052		rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
3053		if (rc != 0)
3054			goto out;
3055	}
3056
3057	/* skip mode change if it's just for clearing setuid/setgid */
3058	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3059		attrs->ia_valid &= ~ATTR_MODE;
3060
3061	args = kmalloc(sizeof(*args), GFP_KERNEL);
3062	if (args == NULL) {
3063		rc = -ENOMEM;
3064		goto out;
3065	}
3066
3067	/* set up the struct */
3068	if (attrs->ia_valid & ATTR_MODE)
3069		args->mode = attrs->ia_mode;
3070	else
3071		args->mode = NO_CHANGE_64;
3072
3073	if (attrs->ia_valid & ATTR_UID)
3074		args->uid = attrs->ia_uid;
3075	else
3076		args->uid = INVALID_UID; /* no change */
3077
3078	if (attrs->ia_valid & ATTR_GID)
3079		args->gid = attrs->ia_gid;
3080	else
3081		args->gid = INVALID_GID; /* no change */
3082
3083	if (attrs->ia_valid & ATTR_ATIME)
3084		args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
3085	else
3086		args->atime = NO_CHANGE_64;
3087
3088	if (attrs->ia_valid & ATTR_MTIME)
3089		args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
3090	else
3091		args->mtime = NO_CHANGE_64;
3092
3093	if (attrs->ia_valid & ATTR_CTIME)
3094		args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
3095	else
3096		args->ctime = NO_CHANGE_64;
3097
3098	args->device = 0;
3099	open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
3100	if (open_file) {
3101		u16 nfid = open_file->fid.netfid;
3102		u32 npid = open_file->pid;
3103		pTcon = tlink_tcon(open_file->tlink);
3104		rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
3105		cifsFileInfo_put(open_file);
3106	} else {
3107		tlink = cifs_sb_tlink(cifs_sb);
3108		if (IS_ERR(tlink)) {
3109			rc = PTR_ERR(tlink);
3110			goto out;
3111		}
3112		pTcon = tlink_tcon(tlink);
3113		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
3114				    cifs_sb->local_nls,
3115				    cifs_remap(cifs_sb));
3116		cifs_put_tlink(tlink);
3117	}
3118
3119	if (rc)
3120		goto out;
3121
3122	if ((attrs->ia_valid & ATTR_SIZE) &&
3123	    attrs->ia_size != i_size_read(inode)) {
3124		truncate_setsize(inode, attrs->ia_size);
3125		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
3126		fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3127	}
3128
3129	setattr_copy(&nop_mnt_idmap, inode, attrs);
3130	mark_inode_dirty(inode);
3131
3132	/* force revalidate when any of these times are set since some
3133	   of the fs types (eg ext3, fat) do not have fine enough
3134	   time granularity to match protocol, and we do not have a
3135	   a way (yet) to query the server fs's time granularity (and
3136	   whether it rounds times down).
3137	*/
3138	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
3139		cifsInode->time = 0;
3140out:
3141	kfree(args);
3142	free_dentry_path(page);
3143	free_xid(xid);
3144	return rc;
3145}
3146#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3147
3148static int
3149cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
3150{
3151	unsigned int xid;
3152	kuid_t uid = INVALID_UID;
3153	kgid_t gid = INVALID_GID;
3154	struct inode *inode = d_inode(direntry);
3155	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3156	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
3157	struct cifsFileInfo *wfile;
3158	struct cifs_tcon *tcon;
3159	const char *full_path;
3160	void *page = alloc_dentry_path();
3161	int rc = -EACCES;
3162	__u32 dosattr = 0;
3163	__u64 mode = NO_CHANGE_64;
3164	bool posix = cifs_sb_master_tcon(cifs_sb)->posix_extensions;
3165
3166	xid = get_xid();
3167
3168	cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
3169		 direntry, attrs->ia_valid);
3170
3171	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3172		attrs->ia_valid |= ATTR_FORCE;
3173
3174	rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3175	if (rc < 0)
3176		goto cifs_setattr_exit;
3177
3178	full_path = build_path_from_dentry(direntry, page);
3179	if (IS_ERR(full_path)) {
3180		rc = PTR_ERR(full_path);
3181		goto cifs_setattr_exit;
3182	}
3183
3184	/*
3185	 * Attempt to flush data before changing attributes. We need to do
3186	 * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
3187	 * returns error, store it to report later and continue.
3188	 *
3189	 * BB: This should be smarter. Why bother flushing pages that
3190	 * will be truncated anyway? Also, should we error out here if
3191	 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
3192	 */
3193	if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
3194		rc = filemap_write_and_wait(inode->i_mapping);
3195		if (is_interrupt_error(rc)) {
3196			rc = -ERESTARTSYS;
3197			goto cifs_setattr_exit;
3198		}
3199		mapping_set_error(inode->i_mapping, rc);
3200	}
3201
3202	rc = 0;
3203
3204	if ((attrs->ia_valid & ATTR_MTIME) &&
3205	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
3206		rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
3207		if (!rc) {
3208			tcon = tlink_tcon(wfile->tlink);
3209			rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
3210			cifsFileInfo_put(wfile);
3211			if (rc)
3212				goto cifs_setattr_exit;
3213		} else if (rc != -EBADF)
3214			goto cifs_setattr_exit;
3215		else
3216			rc = 0;
3217	}
3218
3219	if (attrs->ia_valid & ATTR_SIZE) {
3220		rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
3221		if (rc != 0)
3222			goto cifs_setattr_exit;
3223	}
3224
3225	if (attrs->ia_valid & ATTR_UID)
3226		uid = attrs->ia_uid;
3227
3228	if (attrs->ia_valid & ATTR_GID)
3229		gid = attrs->ia_gid;
3230
3231	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3232	    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
3233		if (uid_valid(uid) || gid_valid(gid)) {
3234			mode = NO_CHANGE_64;
3235			rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3236							uid, gid);
3237			if (rc) {
3238				cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
3239					 __func__, rc);
3240				goto cifs_setattr_exit;
3241			}
3242		}
3243	} else
3244	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
3245		attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
3246
3247	/* skip mode change if it's just for clearing setuid/setgid */
3248	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3249		attrs->ia_valid &= ~ATTR_MODE;
3250
3251	if (attrs->ia_valid & ATTR_MODE) {
3252		mode = attrs->ia_mode;
3253		rc = 0;
3254		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3255		    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) ||
3256		    posix) {
3257			rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3258						INVALID_UID, INVALID_GID);
3259			if (rc) {
3260				cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
3261					 __func__, rc);
3262				goto cifs_setattr_exit;
3263			}
3264
3265			/*
3266			 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3267			 * Pick up the actual mode bits that were set.
3268			 */
3269			if (mode != attrs->ia_mode)
3270				attrs->ia_mode = mode;
3271		} else
3272		if (((mode & S_IWUGO) == 0) &&
3273		    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3274
3275			dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3276
3277			/* fix up mode if we're not using dynperm */
3278			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3279				attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3280		} else if ((mode & S_IWUGO) &&
3281			   (cifsInode->cifsAttrs & ATTR_READONLY)) {
3282
3283			dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3284			/* Attributes of 0 are ignored */
3285			if (dosattr == 0)
3286				dosattr |= ATTR_NORMAL;
3287
3288			/* reset local inode permissions to normal */
3289			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3290				attrs->ia_mode &= ~(S_IALLUGO);
3291				if (S_ISDIR(inode->i_mode))
3292					attrs->ia_mode |=
3293						cifs_sb->ctx->dir_mode;
3294				else
3295					attrs->ia_mode |=
3296						cifs_sb->ctx->file_mode;
3297			}
3298		} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3299			/* ignore mode change - ATTR_READONLY hasn't changed */
3300			attrs->ia_valid &= ~ATTR_MODE;
3301		}
3302	}
3303
3304	if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3305	    ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3306		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3307		/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3308
3309		/* Even if error on time set, no sense failing the call if
3310		the server would set the time to a reasonable value anyway,
3311		and this check ensures that we are not being called from
3312		sys_utimes in which case we ought to fail the call back to
3313		the user when the server rejects the call */
3314		if ((rc) && (attrs->ia_valid &
3315				(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3316			rc = 0;
3317	}
3318
3319	/* do not need local check to inode_check_ok since the server does
3320	   that */
3321	if (rc)
3322		goto cifs_setattr_exit;
3323
3324	if ((attrs->ia_valid & ATTR_SIZE) &&
3325	    attrs->ia_size != i_size_read(inode)) {
3326		truncate_setsize(inode, attrs->ia_size);
3327		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
3328		fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3329	}
3330
3331	setattr_copy(&nop_mnt_idmap, inode, attrs);
3332	mark_inode_dirty(inode);
3333
3334cifs_setattr_exit:
3335	free_xid(xid);
3336	free_dentry_path(page);
3337	return rc;
3338}
3339
3340int
3341cifs_setattr(struct mnt_idmap *idmap, struct dentry *direntry,
3342	     struct iattr *attrs)
3343{
3344	struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3345	int rc, retries = 0;
3346#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3347	struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3348#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3349
3350	if (unlikely(cifs_forced_shutdown(cifs_sb)))
3351		return -EIO;
3352
3353	do {
3354#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3355		if (pTcon->unix_ext)
3356			rc = cifs_setattr_unix(direntry, attrs);
3357		else
3358#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3359			rc = cifs_setattr_nounix(direntry, attrs);
3360		retries++;
3361	} while (is_retryable_error(rc) && retries < 2);
3362
3363	/* BB: add cifs_setattr_legacy for really old servers */
3364	return rc;
3365}