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