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