inode.c 49.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *   fs/cifs/inode.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2007
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
#include <linux/fs.h>
#include <linux/stat.h>
#include <linux/pagemap.h>
#include <asm/div64.h>
#include "cifsfs.h"
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "cifs_fs_sb.h"

32

33
static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
{
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_op = &cifs_file_inode_ops;
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
				inode->i_fop = &cifs_file_direct_nobrl_ops;
			else
				inode->i_fop = &cifs_file_direct_ops;
		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
			inode->i_fop = &cifs_file_nobrl_ops;
		else { /* not direct, send byte range locks */
			inode->i_fop = &cifs_file_ops;
		}


		/* check if server can support readpages */
		if (cifs_sb->tcon->ses->server->maxBuf <
				PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
			inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
		else
			inode->i_data.a_ops = &cifs_addr_ops;
		break;
	case S_IFDIR:
S
Steve French 已提交
60
#ifdef CONFIG_CIFS_DFS_UPCALL
61 62 63
		if (is_dfs_referral) {
			inode->i_op = &cifs_dfs_referral_inode_operations;
		} else {
S
Steve French 已提交
64 65 66
#else /* NO DFS support, treat as a directory */
		{
#endif
67 68 69
			inode->i_op = &cifs_dir_inode_ops;
			inode->i_fop = &cifs_dir_ops;
		}
70 71 72 73 74 75 76 77 78 79
		break;
	case S_IFLNK:
		inode->i_op = &cifs_symlink_inode_ops;
		break;
	default:
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
		break;
	}
}

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
static void cifs_unix_info_to_inode(struct inode *inode,
		FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
{
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
	struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
	__u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
	__u64 end_of_file = le64_to_cpu(info->EndOfFile);

	inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
	inode->i_mtime =
		cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
	inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
	inode->i_mode = le64_to_cpu(info->Permissions);

	/*
	 * Since we set the inode type below we need to mask off
	 * to avoid strange results if bits set above.
	 */
	inode->i_mode &= ~S_IFMT;
	switch (le32_to_cpu(info->Type)) {
	case UNIX_FILE:
		inode->i_mode |= S_IFREG;
		break;
	case UNIX_SYMLINK:
		inode->i_mode |= S_IFLNK;
		break;
	case UNIX_DIR:
		inode->i_mode |= S_IFDIR;
		break;
	case UNIX_CHARDEV:
		inode->i_mode |= S_IFCHR;
		inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
				      le64_to_cpu(info->DevMinor) & MINORMASK);
		break;
	case UNIX_BLOCKDEV:
		inode->i_mode |= S_IFBLK;
		inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
				      le64_to_cpu(info->DevMinor) & MINORMASK);
		break;
	case UNIX_FIFO:
		inode->i_mode |= S_IFIFO;
		break;
	case UNIX_SOCKET:
		inode->i_mode |= S_IFSOCK;
		break;
	default:
		/* safest to call it a file if we do not know */
		inode->i_mode |= S_IFREG;
		cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
		break;
	}

	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
	    !force_uid_gid)
		inode->i_uid = cifs_sb->mnt_uid;
	else
		inode->i_uid = le64_to_cpu(info->Uid);

	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
	    !force_uid_gid)
		inode->i_gid = cifs_sb->mnt_gid;
	else
		inode->i_gid = le64_to_cpu(info->Gid);

	inode->i_nlink = le64_to_cpu(info->Nlinks);

	spin_lock(&inode->i_lock);
	if (is_size_safe_to_change(cifsInfo, end_of_file)) {
		/*
		 * We can not safely change the file size here if the client
		 * is writing to it due to potential races.
		 */
		i_size_write(inode, end_of_file);

		/*
		 * i_blocks is not related to (i_size / i_blksize),
		 * but instead 512 byte (2**9) size is required for
		 * calculating num blocks.
		 */
		inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
	}
	spin_unlock(&inode->i_lock);
}

164 165 166 167 168 169

/*
 *	Needed to setup inode data for the directory which is the
 *	junction to the new submount (ie to setup the fake directory
 *      which represents a DFS referral)
 */
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
			       struct super_block *sb)
{
	struct inode *pinode = NULL;

	memset(pfnd_dat, sizeof(FILE_UNIX_BASIC_INFO), 0);

/*	__le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
	__le64 pfnd_dat->NumOfBytes = cpu_to_le64(0);
	__u64 UniqueId = 0;  */
	pfnd_dat->LastStatusChange =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->LastAccessTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->LastModificationTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->Type = cpu_to_le32(UNIX_DIR);
	pfnd_dat->Permissions = cpu_to_le64(S_IXUGO | S_IRWXU);
	pfnd_dat->Nlinks = cpu_to_le64(2);
	if (sb->s_root)
		pinode = sb->s_root->d_inode;
	if (pinode == NULL)
		return;

	/* fill in default values for the remaining based on root
	   inode since we can not query the server for this inode info */
	pfnd_dat->DevMajor = cpu_to_le64(MAJOR(pinode->i_rdev));
	pfnd_dat->DevMinor = cpu_to_le64(MINOR(pinode->i_rdev));
	pfnd_dat->Uid = cpu_to_le64(pinode->i_uid);
	pfnd_dat->Gid = cpu_to_le64(pinode->i_gid);
}

L
Linus Torvalds 已提交
202
int cifs_get_inode_info_unix(struct inode **pinode,
203
	const unsigned char *full_path, struct super_block *sb, int xid)
L
Linus Torvalds 已提交
204 205
{
	int rc = 0;
206
	FILE_UNIX_BASIC_INFO find_data;
L
Linus Torvalds 已提交
207 208 209
	struct cifsTconInfo *pTcon;
	struct inode *inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
210
	bool is_dfs_referral = false;
211 212 213
	struct cifsInodeInfo *cifsInfo;
	__u64 num_of_bytes;
	__u64 end_of_file;
L
Linus Torvalds 已提交
214 215

	pTcon = cifs_sb->tcon;
216
	cFYI(1, ("Getting info on %s", full_path));
217

L
Linus Torvalds 已提交
218
	/* could have done a find first instead but this returns more info */
219
	rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &find_data,
220 221
				  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
222
	if (rc) {
223 224
		if (rc == -EREMOTE && !is_dfs_referral) {
			is_dfs_referral = true;
S
Steve French 已提交
225
			cFYI(DBG2, ("DFS ref"));
226 227 228
			/* for DFS, server does not give us real inode data */
			fill_fake_finddataunix(&find_data, sb);
			rc = 0;
L
Linus Torvalds 已提交
229
		}
230 231 232
	}
	num_of_bytes = le64_to_cpu(find_data.NumOfBytes);
	end_of_file = le64_to_cpu(find_data.EndOfFile);
L
Linus Torvalds 已提交
233

234 235 236
	/* get new inode */
	if (*pinode == NULL) {
		*pinode = new_inode(sb);
L
Linus Torvalds 已提交
237
		if (*pinode == NULL) {
238 239
			rc = -ENOMEM;
		goto cgiiu_exit;
L
Linus Torvalds 已提交
240
		}
241 242 243 244 245 246
		/* Is an i_ino of zero legal? */
		/* note ino incremented to unique num in new_inode */
		/* Are there sanity checks we can use to ensure that
		   the server is really filling in that field? */
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
			(*pinode)->i_ino = (unsigned long)find_data.UniqueId;
L
Linus Torvalds 已提交
247

248 249
		if (sb->s_flags & MS_NOATIME)
			(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
L
Linus Torvalds 已提交
250

251 252
		insert_inode_hash(*pinode);
	}
L
Linus Torvalds 已提交
253

254 255
	inode = *pinode;
	cifsInfo = CIFS_I(inode);
L
Linus Torvalds 已提交
256

257 258 259 260 261
	cFYI(1, ("Old time %ld", cifsInfo->time));
	cifsInfo->time = jiffies;
	cFYI(1, ("New time %ld", cifsInfo->time));
	/* this is ok to set on every inode revalidate */
	atomic_set(&cifsInfo->inUse, 1);
L
Linus Torvalds 已提交
262

263
	cifs_unix_info_to_inode(inode, &find_data, 0);
264

265 266 267 268 269 270 271
	if (num_of_bytes < end_of_file)
		cFYI(1, ("allocation size less than end of file"));
	cFYI(1, ("Size %ld and blocks %llu",
		(unsigned long) inode->i_size,
		(unsigned long long)inode->i_blocks));

	cifs_set_ops(inode, is_dfs_referral);
272
cgiiu_exit:
L
Linus Torvalds 已提交
273 274 275
	return rc;
}

S
Steve French 已提交
276
static int decode_sfu_inode(struct inode *inode, __u64 size,
277 278 279 280
			    const unsigned char *path,
			    struct cifs_sb_info *cifs_sb, int xid)
{
	int rc;
281
	int oplock = 0;
282 283
	__u16 netfid;
	struct cifsTconInfo *pTcon = cifs_sb->tcon;
284
	char buf[24];
285
	unsigned int bytes_read;
S
Steve French 已提交
286
	char *pbuf;
287 288 289

	pbuf = buf;

290
	if (size == 0) {
291 292 293 294 295
		inode->i_mode |= S_IFIFO;
		return 0;
	} else if (size < 8) {
		return -EINVAL;	 /* EOPNOTSUPP? */
	}
296

297 298 299 300 301
	rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
			 cifs_sb->local_nls,
			 cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
302
	if (rc == 0) {
303
		int buf_type = CIFS_NO_BUFFER;
304 305
			/* Read header */
		rc = CIFSSMBRead(xid, pTcon,
S
Steve French 已提交
306
				 netfid,
307
				 24 /* length */, 0 /* offset */,
308
				 &bytes_read, &pbuf, &buf_type);
309 310
		if ((rc == 0) && (bytes_read >= 8)) {
			if (memcmp("IntxBLK", pbuf, 8) == 0) {
S
Steve French 已提交
311
				cFYI(1, ("Block device"));
312
				inode->i_mode |= S_IFBLK;
313
				if (bytes_read == 24) {
314 315 316 317 318 319 320
					/* we have enough to decode dev num */
					__u64 mjr; /* major */
					__u64 mnr; /* minor */
					mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
					inode->i_rdev = MKDEV(mjr, mnr);
				}
321
			} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
S
Steve French 已提交
322
				cFYI(1, ("Char device"));
323
				inode->i_mode |= S_IFCHR;
324
				if (bytes_read == 24) {
325 326 327 328 329 330
					/* we have enough to decode dev num */
					__u64 mjr; /* major */
					__u64 mnr; /* minor */
					mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
					inode->i_rdev = MKDEV(mjr, mnr);
S
Steve French 已提交
331
				}
332
			} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
S
Steve French 已提交
333
				cFYI(1, ("Symlink"));
334
				inode->i_mode |= S_IFLNK;
335 336
			} else {
				inode->i_mode |= S_IFREG; /* file? */
S
Steve French 已提交
337
				rc = -EOPNOTSUPP;
338
			}
339 340
		} else {
			inode->i_mode |= S_IFREG; /* then it is a file */
S
Steve French 已提交
341 342
			rc = -EOPNOTSUPP; /* or some unknown SFU type */
		}
343 344 345 346 347
		CIFSSMBClose(xid, pTcon, netfid);
	}
	return rc;
}

348 349
#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */

350
static int get_sfu_mode(struct inode *inode,
351 352 353
			const unsigned char *path,
			struct cifs_sb_info *cifs_sb, int xid)
{
354
#ifdef CONFIG_CIFS_XATTR
355 356 357 358 359 360
	ssize_t rc;
	char ea_value[4];
	__u32 mode;

	rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
			ea_value, 4 /* size of buf */, cifs_sb->local_nls,
S
Steve French 已提交
361
		cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
362
	if (rc < 0)
363 364 365
		return (int)rc;
	else if (rc > 3) {
		mode = le32_to_cpu(*((__le32 *)ea_value));
S
Steve French 已提交
366 367
		inode->i_mode &= ~SFBITS_MASK;
		cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
368
		inode->i_mode = (mode &  SFBITS_MASK) | inode->i_mode;
S
Steve French 已提交
369
		cFYI(1, ("special mode bits 0%o", mode));
370 371 372 373
		return 0;
	} else {
		return 0;
	}
374 375 376
#else
	return -EOPNOTSUPP;
#endif
377 378
}

379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
/*
 *	Needed to setup inode data for the directory which is the
 *	junction to the new submount (ie to setup the fake directory
 *      which represents a DFS referral)
 */
static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
			       struct super_block *sb)
{
	memset(pfnd_dat, sizeof(FILE_ALL_INFO), 0);

/*	__le64 pfnd_dat->AllocationSize = cpu_to_le64(0);
	__le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
	__u8 pfnd_dat->DeletePending = 0;
	__u8 pfnd_data->Directory = 0;
	__le32 pfnd_dat->EASize = 0;
	__u64 pfnd_dat->IndexNumber = 0;
	__u64 pfnd_dat->IndexNumber1 = 0;  */
	pfnd_dat->CreationTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->LastAccessTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->LastWriteTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->ChangeTime =
		cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
	pfnd_dat->Attributes = cpu_to_le32(ATTR_DIRECTORY);
	pfnd_dat->NumberOfLinks = cpu_to_le32(2);
}

L
Linus Torvalds 已提交
408
int cifs_get_inode_info(struct inode **pinode,
409
	const unsigned char *full_path, FILE_ALL_INFO *pfindData,
410
	struct super_block *sb, int xid, const __u16 *pfid)
L
Linus Torvalds 已提交
411 412
{
	int rc = 0;
413 414
	__u32 attr;
	struct cifsInodeInfo *cifsInfo;
L
Linus Torvalds 已提交
415 416 417 418
	struct cifsTconInfo *pTcon;
	struct inode *inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	char *buf = NULL;
S
Steve French 已提交
419
	bool adjustTZ = false;
420
	bool is_dfs_referral = false;
L
Linus Torvalds 已提交
421 422

	pTcon = cifs_sb->tcon;
423
	cFYI(1, ("Getting info on %s", full_path));
L
Linus Torvalds 已提交
424

425 426
	if ((pfindData == NULL) && (*pinode != NULL)) {
		if (CIFS_I(*pinode)->clientCanCacheRead) {
S
Steve French 已提交
427
			cFYI(1, ("No need to revalidate cached inode sizes"));
L
Linus Torvalds 已提交
428 429 430 431 432
			return rc;
		}
	}

	/* if file info not passed in then get it from server */
433
	if (pfindData == NULL) {
L
Linus Torvalds 已提交
434
		buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
435
		if (buf == NULL)
L
Linus Torvalds 已提交
436 437
			return -ENOMEM;
		pfindData = (FILE_ALL_INFO *)buf;
438

L
Linus Torvalds 已提交
439
		/* could do find first instead but this returns more info */
440
		rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
441
			      0 /* not legacy */,
442
			      cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
443
				CIFS_MOUNT_MAP_SPECIAL_CHR);
444 445 446
		/* BB optimize code so we do not make the above call
		when server claims no NT SMB support and the above call
		failed at least once - set flag in tcon or mount */
447
		if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
448
			rc = SMBQueryInformation(xid, pTcon, full_path,
S
Steve French 已提交
449
					pfindData, cifs_sb->local_nls,
450 451
					cifs_sb->mnt_cifs_flags &
					  CIFS_MOUNT_MAP_SPECIAL_CHR);
452
			adjustTZ = true;
453
		}
L
Linus Torvalds 已提交
454 455
	}
	/* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
456 457 458 459 460
	if (rc == -EREMOTE) {
		is_dfs_referral = true;
		fill_fake_finddata(pfindData, sb);
		rc = 0;
	} else if (rc)
461
		goto cgii_exit;
L
Linus Torvalds 已提交
462

463 464 465 466 467
	attr = le32_to_cpu(pfindData->Attributes);

	/* get new inode */
	if (*pinode == NULL) {
		*pinode = new_inode(sb);
L
Linus Torvalds 已提交
468
		if (*pinode == NULL) {
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
			rc = -ENOMEM;
			goto cgii_exit;
		}
		/* Is an i_ino of zero legal? Can we use that to check
		   if the server supports returning inode numbers?  Are
		   there other sanity checks we can use to ensure that
		   the server is really filling in that field? */

		/* We can not use the IndexNumber field by default from
		   Windows or Samba (in ALL_INFO buf) but we can request
		   it explicitly.  It may not be unique presumably if
		   the server has multiple devices mounted under one share */

		/* There may be higher info levels that work but are
		   there Windows server or network appliances for which
		   IndexNumber field is not guaranteed unique? */

		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
			int rc1 = 0;
			__u64 inode_num;

			rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
491
					full_path, &inode_num,
492 493 494
					cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
			if (rc1) {
				cFYI(1, ("GetSrvInodeNum rc %d", rc1));
				/* BB EOPNOSUPP disable SERVER_INUM? */
			} else /* do we need cast or hash to ino? */
				(*pinode)->i_ino = inode_num;
		} /* else ino incremented to unique num in new_inode*/
		if (sb->s_flags & MS_NOATIME)
			(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
		insert_inode_hash(*pinode);
	}
	inode = *pinode;
	cifsInfo = CIFS_I(inode);
	cifsInfo->cifsAttrs = attr;
	cFYI(1, ("Old time %ld", cifsInfo->time));
	cifsInfo->time = jiffies;
	cFYI(1, ("New time %ld", cifsInfo->time));

	/* blksize needs to be multiple of two. So safer to default to
	blksize and blkbits set in superblock so 2**blkbits and blksize
	will match rather than setting to:
	(pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/

	/* Linux can not store file creation time so ignore it */
	if (pfindData->LastAccessTime)
		inode->i_atime = cifs_NTtimeToUnix
			(le64_to_cpu(pfindData->LastAccessTime));
	else /* do not need to use current_fs_time - time not stored */
		inode->i_atime = CURRENT_TIME;
	inode->i_mtime =
L
Linus Torvalds 已提交
524
		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
525 526 527 528 529 530 531
	inode->i_ctime =
	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
	cFYI(DBG2, ("Attributes came in as 0x%x", attr));
	if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
		inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
		inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
	}
L
Linus Torvalds 已提交
532

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	/* set default mode. will override for dirs below */
	if (atomic_read(&cifsInfo->inUse) == 0)
		/* new inode, can safely set these fields */
		inode->i_mode = cifs_sb->mnt_file_mode;
	else /* since we set the inode type below we need to mask off
	     to avoid strange results if type changes and both
	     get orred in */
		inode->i_mode &= ~S_IFMT;
/*	if (attr & ATTR_REPARSE)  */
	/* We no longer handle these as symlinks because we could not
	   follow them due to the absolute path with drive letter */
	if (attr & ATTR_DIRECTORY) {
	/* override default perms since we do not do byte range locking
	   on dirs */
		inode->i_mode = cifs_sb->mnt_dir_mode;
		inode->i_mode |= S_IFDIR;
	} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
		   (cifsInfo->cifsAttrs & ATTR_SYSTEM) &&
		   /* No need to le64 convert size of zero */
		   (pfindData->EndOfFile == 0)) {
		inode->i_mode = cifs_sb->mnt_file_mode;
		inode->i_mode |= S_IFIFO;
555
/* BB Finish for SFU style symlinks and devices */
556 557 558 559 560
	} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
		   (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
		if (decode_sfu_inode(inode, le64_to_cpu(pfindData->EndOfFile),
				     full_path, cifs_sb, xid))
			cFYI(1, ("Unrecognized sfu inode type"));
561

562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
		cFYI(1, ("sfu mode 0%o", inode->i_mode));
	} else {
		inode->i_mode |= S_IFREG;
		/* treat dos attribute of read-only as read-only mode eg 555 */
		if (cifsInfo->cifsAttrs & ATTR_READONLY)
			inode->i_mode &= ~(S_IWUGO);
		else if ((inode->i_mode & S_IWUGO) == 0)
			/* the ATTR_READONLY flag may have been	*/
			/* changed on server -- set any w bits	*/
			/* allowed by mnt_file_mode		*/
			inode->i_mode |= (S_IWUGO & cifs_sb->mnt_file_mode);
	/* BB add code to validate if device or weird share or device type? */
	}

	spin_lock(&inode->i_lock);
	if (is_size_safe_to_change(cifsInfo,
				   le64_to_cpu(pfindData->EndOfFile))) {
		/* can not safely shrink the file size here if the
		   client is writing to it due to potential races */
		i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));

		/* 512 bytes (2**9) is the fake blocksize that must be
		   used for this calculation */
		inode->i_blocks = (512 - 1 + le64_to_cpu(
				   pfindData->AllocationSize)) >> 9;
	}
	spin_unlock(&inode->i_lock);
L
Linus Torvalds 已提交
589

590
	inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
L
Linus Torvalds 已提交
591

592 593
	/* BB fill in uid and gid here? with help from winbind?
	   or retrieve from NTFS stream extended attribute */
S
Steve French 已提交
594
#ifdef CONFIG_CIFS_EXPERIMENTAL
595 596 597 598 599
	/* fill in 0777 bits from ACL */
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
		cFYI(1, ("Getting mode bits from ACL"));
		acl_to_uid_mode(inode, full_path, pfid);
	}
S
Steve French 已提交
600
#endif
601 602 603 604 605 606 607 608 609
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
		/* fill in remaining high mode bits e.g. SUID, VTX */
		get_sfu_mode(inode, full_path, cifs_sb, xid);
	} else if (atomic_read(&cifsInfo->inUse) == 0) {
		inode->i_uid = cifs_sb->mnt_uid;
		inode->i_gid = cifs_sb->mnt_gid;
		/* set so we do not keep refreshing these fields with
		   bad data after user has changed them in memory */
		atomic_set(&cifsInfo->inUse, 1);
L
Linus Torvalds 已提交
610
	}
611 612 613 614 615 616

	cifs_set_ops(inode, is_dfs_referral);




617
cgii_exit:
L
Linus Torvalds 已提交
618 619 620 621
	kfree(buf);
	return rc;
}

622 623 624 625
static const struct inode_operations cifs_ipc_inode_ops = {
	.lookup = cifs_lookup,
};

L
Linus Torvalds 已提交
626
/* gets root inode */
627
struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
L
Linus Torvalds 已提交
628
{
629
	int xid;
L
Linus Torvalds 已提交
630
	struct cifs_sb_info *cifs_sb;
631 632 633 634 635 636 637 638
	struct inode *inode;
	long rc;

	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;
L
Linus Torvalds 已提交
639 640 641

	cifs_sb = CIFS_SB(inode->i_sb);
	xid = GetXid();
642 643

	if (cifs_sb->tcon->unix_ext)
644
		rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
L
Linus Torvalds 已提交
645
	else
646 647
		rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid,
					 NULL);
648 649 650 651 652 653 654 655
	if (rc && cifs_sb->tcon->ipc) {
		cFYI(1, ("ipc connection - fake read inode"));
		inode->i_mode |= S_IFDIR;
		inode->i_nlink = 2;
		inode->i_op = &cifs_ipc_inode_ops;
		inode->i_fop = &simple_dir_operations;
		inode->i_uid = cifs_sb->mnt_uid;
		inode->i_gid = cifs_sb->mnt_gid;
656 657 658
		_FreeXid(xid);
		iget_failed(inode);
		return ERR_PTR(rc);
659 660
	}

661 662 663 664 665
	unlock_new_inode(inode);

	/* can not call macro FreeXid here since in a void func
	 * TODO: This is no longer true
	 */
L
Linus Torvalds 已提交
666
	_FreeXid(xid);
667
	return inode;
L
Linus Torvalds 已提交
668 669 670 671 672 673 674 675 676 677 678 679
}

int cifs_unlink(struct inode *inode, struct dentry *direntry)
{
	int rc = 0;
	int xid;
	struct cifs_sb_info *cifs_sb;
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	struct cifsInodeInfo *cifsInode;
	FILE_BASIC_INFO *pinfo_buf;

680
	cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
L
Linus Torvalds 已提交
681 682 683

	xid = GetXid();

684
	if (inode)
685 686
		cifs_sb = CIFS_SB(inode->i_sb);
	else
687
		cifs_sb = CIFS_SB(direntry->d_sb);
L
Linus Torvalds 已提交
688 689 690 691
	pTcon = cifs_sb->tcon;

	/* Unlink can be called from rename so we can not grab the sem here
	   since we deadlock otherwise */
692
/*	mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
693
	full_path = build_path_from_dentry(direntry);
694
/*	mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
L
Linus Torvalds 已提交
695 696 697 698
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
699 700 701 702 703 704

	if ((pTcon->ses->capabilities & CAP_UNIX) &&
		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
		rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
705
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
706 707 708 709
		cFYI(1, ("posix del rc %d", rc));
		if ((rc == 0) || (rc == -ENOENT))
			goto psx_del_no_retry;
	}
L
Linus Torvalds 已提交
710

711 712 713
	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
psx_del_no_retry:
L
Linus Torvalds 已提交
714
	if (!rc) {
715
		if (direntry->d_inode)
716
			drop_nlink(direntry->d_inode);
L
Linus Torvalds 已提交
717 718 719
	} else if (rc == -ENOENT) {
		d_drop(direntry);
	} else if (rc == -ETXTBSY) {
720
		int oplock = 0;
L
Linus Torvalds 已提交
721 722 723 724
		__u16 netfid;

		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
				 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
725
				 &netfid, &oplock, NULL, cifs_sb->local_nls,
S
Steve French 已提交
726
				 cifs_sb->mnt_cifs_flags &
727
					CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
728
		if (rc == 0) {
L
Linus Torvalds 已提交
729
			CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
S
Steve French 已提交
730 731
					      cifs_sb->local_nls,
					      cifs_sb->mnt_cifs_flags &
732
						CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
733
			CIFSSMBClose(xid, pTcon, netfid);
734
			if (direntry->d_inode)
735
				drop_nlink(direntry->d_inode);
L
Linus Torvalds 已提交
736 737 738
		}
	} else if (rc == -EACCES) {
		/* try only if r/o attribute set in local lookup data? */
739
		pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
L
Linus Torvalds 已提交
740 741 742 743 744 745
		if (pinfo_buf) {
			/* ATTRS set to normal clears r/o bit */
			pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
			if (!(pTcon->ses->flags & CIFS_SES_NT4))
				rc = CIFSSMBSetTimes(xid, pTcon, full_path,
						     pinfo_buf,
746
						     cifs_sb->local_nls,
S
Steve French 已提交
747
						     cifs_sb->mnt_cifs_flags &
748
							CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
749 750 751 752
			else
				rc = -EOPNOTSUPP;

			if (rc == -EOPNOTSUPP) {
753
				int oplock = 0;
L
Linus Torvalds 已提交
754 755 756 757
				__u16 netfid;
			/*	rc = CIFSSMBSetAttrLegacy(xid, pTcon,
							  full_path,
							  (__u16)ATTR_NORMAL,
S
Steve French 已提交
758
							  cifs_sb->local_nls);
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768 769
			   For some strange reason it seems that NT4 eats the
			   old setattr call without actually setting the
			   attributes so on to the third attempted workaround
			   */

			/* BB could scan to see if we already have it open
			   and pass in pid of opener to function */
				rc = CIFSSMBOpen(xid, pTcon, full_path,
						 FILE_OPEN, SYNCHRONIZE |
						 FILE_WRITE_ATTRIBUTES, 0,
						 &netfid, &oplock, NULL,
770
						 cifs_sb->local_nls,
S
Steve French 已提交
771
						 cifs_sb->mnt_cifs_flags &
772
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
773
				if (rc == 0) {
L
Linus Torvalds 已提交
774 775 776 777 778 779 780 781
					rc = CIFSSMBSetFileTimes(xid, pTcon,
								 pinfo_buf,
								 netfid);
					CIFSSMBClose(xid, pTcon, netfid);
				}
			}
			kfree(pinfo_buf);
		}
S
Steve French 已提交
782 783 784 785
		if (rc == 0) {
			rc = CIFSSMBDelFile(xid, pTcon, full_path,
					    cifs_sb->local_nls,
					    cifs_sb->mnt_cifs_flags &
786
						CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
787
			if (!rc) {
788
				if (direntry->d_inode)
789
					drop_nlink(direntry->d_inode);
L
Linus Torvalds 已提交
790
			} else if (rc == -ETXTBSY) {
791
				int oplock = 0;
L
Linus Torvalds 已提交
792 793 794 795 796 797 798
				__u16 netfid;

				rc = CIFSSMBOpen(xid, pTcon, full_path,
						 FILE_OPEN, DELETE,
						 CREATE_NOT_DIR |
						 CREATE_DELETE_ON_CLOSE,
						 &netfid, &oplock, NULL,
S
Steve French 已提交
799 800
						 cifs_sb->local_nls,
						 cifs_sb->mnt_cifs_flags &
801
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
802
				if (rc == 0) {
L
Linus Torvalds 已提交
803 804
					CIFSSMBRenameOpenFile(xid, pTcon,
						netfid, NULL,
805 806 807
						cifs_sb->local_nls,
						cifs_sb->mnt_cifs_flags &
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
808
					CIFSSMBClose(xid, pTcon, netfid);
809
					if (direntry->d_inode)
810
						drop_nlink(direntry->d_inode);
L
Linus Torvalds 已提交
811 812 813 814 815
				}
			/* BB if rc = -ETXTBUSY goto the rename logic BB */
			}
		}
	}
816
	if (direntry->d_inode) {
817 818 819 820 821
		cifsInode = CIFS_I(direntry->d_inode);
		cifsInode->time = 0;	/* will force revalidate to get info
					   when needed */
		direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
	}
822
	if (inode) {
823 824 825 826
		inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
		cifsInode = CIFS_I(inode);
		cifsInode->time = 0;	/* force revalidate of dir as well */
	}
L
Linus Torvalds 已提交
827 828 829 830 831 832

	kfree(full_path);
	FreeXid(xid);
	return rc;
}

833
static void posix_fill_in_inode(struct inode *tmp_inode,
S
Steve French 已提交
834
	FILE_UNIX_BASIC_INFO *pData, int isNewInode)
835
{
836
	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
837 838 839 840 841 842 843 844 845 846
	loff_t local_size;
	struct timespec local_mtime;

	cifsInfo->time = jiffies;
	atomic_inc(&cifsInfo->inUse);

	/* save mtime and size */
	local_mtime = tmp_inode->i_mtime;
	local_size  = tmp_inode->i_size;

847
	cifs_unix_info_to_inode(tmp_inode, pData, 1);
848
	cifs_set_ops(tmp_inode, false);
849

850 851
	if (!S_ISREG(tmp_inode->i_mode))
		return;
852

853 854 855 856 857 858 859
	/*
	 * No sense invalidating pages for new inode
	 * since we we have not started caching
	 * readahead file data yet.
	 */
	if (isNewInode)
		return;
860

861 862 863
	if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
		(local_size == tmp_inode->i_size)) {
		cFYI(1, ("inode exists but unchanged"));
864
	} else {
865 866 867
		/* file may have changed on server */
		cFYI(1, ("invalidate inode, readdir detected change"));
		invalidate_remote_inode(tmp_inode);
S
Steve French 已提交
868
	}
869 870
}

L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878 879
int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
{
	int rc = 0;
	int xid;
	struct cifs_sb_info *cifs_sb;
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	struct inode *newinode = NULL;

880
	cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
L
Linus Torvalds 已提交
881 882 883 884 885 886

	xid = GetXid();

	cifs_sb = CIFS_SB(inode->i_sb);
	pTcon = cifs_sb->tcon;

887
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
888 889 890 891
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
892

S
Steve French 已提交
893 894
	if ((pTcon->ses->capabilities & CAP_UNIX) &&
		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
895 896
			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
		u32 oplock = 0;
897
		FILE_UNIX_BASIC_INFO *pInfo =
898
			kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
S
Steve French 已提交
899
		if (pInfo == NULL) {
900 901 902
			rc = -ENOMEM;
			goto mkdir_out;
		}
903

904
		mode &= ~current->fs->umask;
905 906
		rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
				mode, NULL /* netfid */, pInfo, &oplock,
S
Steve French 已提交
907 908
				full_path, cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
909
					CIFS_MOUNT_MAP_SPECIAL_CHR);
910 911 912 913
		if (rc == -EOPNOTSUPP) {
			kfree(pInfo);
			goto mkdir_retry_old;
		} else if (rc) {
914 915 916
			cFYI(1, ("posix mkdir returned 0x%x", rc));
			d_drop(direntry);
		} else {
917 918
			if (pInfo->Type == cpu_to_le32(-1)) {
				/* no return info, go query for it */
919
				kfree(pInfo);
S
Steve French 已提交
920
				goto mkdir_get_info;
921
			}
S
Steve French 已提交
922 923
/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
	to set uid/gid */
924 925 926 927 928
			inc_nlink(inode);
			if (pTcon->nocase)
				direntry->d_op = &cifs_ci_dentry_ops;
			else
				direntry->d_op = &cifs_dentry_ops;
929 930

			newinode = new_inode(inode->i_sb);
931 932
			if (newinode == NULL) {
				kfree(pInfo);
933
				goto mkdir_get_info;
934
			}
935 936 937 938 939 940 941
			/* Is an i_ino of zero legal? */
			/* Are there sanity checks we can use to ensure that
			   the server is really filling in that field? */
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
				newinode->i_ino =
					(unsigned long)pInfo->UniqueId;
			} /* note ino incremented to unique num in new_inode */
S
Steve French 已提交
942
			if (inode->i_sb->s_flags & MS_NOATIME)
943 944 945 946
				newinode->i_flags |= S_NOATIME | S_NOCMTIME;
			newinode->i_nlink = 2;

			insert_inode_hash(newinode);
947
			d_instantiate(direntry, newinode);
948 949 950 951

			/* we already checked in POSIXCreate whether
			   frame was long enough */
			posix_fill_in_inode(direntry->d_inode,
S
Steve French 已提交
952
					pInfo, 1 /* NewInode */);
953
#ifdef CONFIG_CIFS_DEBUG2
S
Steve French 已提交
954
			cFYI(1, ("instantiated dentry %p %s to inode %p",
955 956
				direntry, direntry->d_name.name, newinode));

S
Steve French 已提交
957 958
			if (newinode->i_nlink != 2)
				cFYI(1, ("unexpected number of links %d",
959 960
					newinode->i_nlink));
#endif
961 962 963
		}
		kfree(pInfo);
		goto mkdir_out;
S
Steve French 已提交
964
	}
965
mkdir_retry_old:
L
Linus Torvalds 已提交
966
	/* BB add setting the equivalent of mode via CreateX w/ACLs */
967 968
	rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
969
	if (rc) {
970
		cFYI(1, ("cifs_mkdir returned 0x%x", rc));
L
Linus Torvalds 已提交
971 972
		d_drop(direntry);
	} else {
S
Steve French 已提交
973
mkdir_get_info:
974
		inc_nlink(inode);
975
		if (pTcon->unix_ext)
L
Linus Torvalds 已提交
976
			rc = cifs_get_inode_info_unix(&newinode, full_path,
S
Steve French 已提交
977
						      inode->i_sb, xid);
L
Linus Torvalds 已提交
978 979
		else
			rc = cifs_get_inode_info(&newinode, full_path, NULL,
980
						 inode->i_sb, xid, NULL);
L
Linus Torvalds 已提交
981

982 983 984 985
		if (pTcon->nocase)
			direntry->d_op = &cifs_ci_dentry_ops;
		else
			direntry->d_op = &cifs_dentry_ops;
L
Linus Torvalds 已提交
986
		d_instantiate(direntry, newinode);
987
		 /* setting nlink not necessary except in cases where we
S
Steve French 已提交
988
		  * failed to get it from the server or was set bogus */
989
		if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
S
Steve French 已提交
990
				direntry->d_inode->i_nlink = 2;
991
		mode &= ~current->fs->umask;
992
		if (pTcon->unix_ext) {
993
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
L
Linus Torvalds 已提交
994 995
				CIFSSMBUnixSetPerms(xid, pTcon, full_path,
						    mode,
996 997
						    (__u64)current->fsuid,
						    (__u64)current->fsgid,
L
Linus Torvalds 已提交
998
						    0 /* dev_t */,
999 1000 1001
						    cifs_sb->local_nls,
						    cifs_sb->mnt_cifs_flags &
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1002 1003 1004 1005
			} else {
				CIFSSMBUnixSetPerms(xid, pTcon, full_path,
						    mode, (__u64)-1,
						    (__u64)-1, 0 /* dev_t */,
1006
						    cifs_sb->local_nls,
S
Steve French 已提交
1007
						    cifs_sb->mnt_cifs_flags &
1008
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1009
			}
S
Steve French 已提交
1010
		} else {
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
			    (mode & S_IWUGO) == 0) {
				FILE_BASIC_INFO pInfo;
				memset(&pInfo, 0, sizeof(pInfo));
				pInfo.Attributes = cpu_to_le32(ATTR_READONLY);
				CIFSSMBSetTimes(xid, pTcon, full_path,
						&pInfo, cifs_sb->local_nls,
						cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
			}
S
Steve French 已提交
1021
			if (direntry->d_inode) {
1022
				direntry->d_inode->i_mode = mode;
1023
				direntry->d_inode->i_mode |= S_IFDIR;
S
Steve French 已提交
1024
				if (cifs_sb->mnt_cifs_flags &
1025
				     CIFS_MOUNT_SET_UID) {
S
Steve French 已提交
1026
					direntry->d_inode->i_uid =
1027
						current->fsuid;
S
Steve French 已提交
1028
					direntry->d_inode->i_gid =
1029 1030 1031
						current->fsgid;
				}
			}
1032
		}
L
Linus Torvalds 已提交
1033
	}
S
Steve French 已提交
1034
mkdir_out:
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

int cifs_rmdir(struct inode *inode, struct dentry *direntry)
{
	int rc = 0;
	int xid;
	struct cifs_sb_info *cifs_sb;
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	struct cifsInodeInfo *cifsInode;

1049
	cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054 1055

	xid = GetXid();

	cifs_sb = CIFS_SB(inode->i_sb);
	pTcon = cifs_sb->tcon;

1056
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
1057 1058 1059 1060 1061
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}

1062 1063
	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1064 1065

	if (!rc) {
1066
		drop_nlink(inode);
1067
		spin_lock(&direntry->d_inode->i_lock);
S
Steve French 已提交
1068
		i_size_write(direntry->d_inode, 0);
1069
		clear_nlink(direntry->d_inode);
1070
		spin_unlock(&direntry->d_inode->i_lock);
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
	}

	cifsInode = CIFS_I(direntry->d_inode);
	cifsInode->time = 0;	/* force revalidate to go get info when
				   needed */
	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
		current_fs_time(inode->i_sb);

	kfree(full_path);
	FreeXid(xid);
	return rc;
}

int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
	struct inode *target_inode, struct dentry *target_direntry)
{
	char *fromName;
	char *toName;
	struct cifs_sb_info *cifs_sb_source;
	struct cifs_sb_info *cifs_sb_target;
	struct cifsTconInfo *pTcon;
	int xid;
	int rc = 0;

	xid = GetXid();

	cifs_sb_target = CIFS_SB(target_inode->i_sb);
	cifs_sb_source = CIFS_SB(source_inode->i_sb);
	pTcon = cifs_sb_source->tcon;

	if (pTcon != cifs_sb_target->tcon) {
		FreeXid(xid);
		return -EXDEV;	/* BB actually could be allowed if same server,
				   but different share.
				   Might eventually add support for this */
	}

	/* we already  have the rename sem so we do not need to grab it again
	   here to protect the path integrity */
1110 1111
	fromName = build_path_from_dentry(source_direntry);
	toName = build_path_from_dentry(target_direntry);
L
Linus Torvalds 已提交
1112 1113 1114 1115 1116 1117
	if ((fromName == NULL) || (toName == NULL)) {
		rc = -ENOMEM;
		goto cifs_rename_exit;
	}

	rc = CIFSSMBRename(xid, pTcon, fromName, toName,
1118 1119 1120
			   cifs_sb_source->local_nls,
			   cifs_sb_source->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
	if (rc == -EEXIST) {
		/* check if they are the same file because rename of hardlinked
		   files is a noop */
		FILE_UNIX_BASIC_INFO *info_buf_source;
		FILE_UNIX_BASIC_INFO *info_buf_target;

		info_buf_source =
			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
		if (info_buf_source != NULL) {
			info_buf_target = info_buf_source + 1;
1131
			if (pTcon->unix_ext)
1132
				rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
S
Steve French 已提交
1133
					info_buf_source,
1134 1135 1136 1137 1138
					cifs_sb_source->local_nls,
					cifs_sb_source->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
			/* else rc is still EEXIST so will fall through to
			   unlink the target and retry rename */
L
Linus Torvalds 已提交
1139 1140 1141
			if (rc == 0) {
				rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
						info_buf_target,
1142 1143 1144 1145
						cifs_sb_target->local_nls,
						/* remap based on source sb */
						cifs_sb_source->mnt_cifs_flags &
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
			}
			if ((rc == 0) &&
			    (info_buf_source->UniqueId ==
			     info_buf_target->UniqueId)) {
			/* do not rename since the files are hardlinked which
			   is a noop */
			} else {
			/* we either can not tell the files are hardlinked
			   (as with Windows servers) or files are not
			   hardlinked so delete the target manually before
			   renaming to follow POSIX rather than Windows
			   semantics */
				cifs_unlink(target_inode, target_direntry);
				rc = CIFSSMBRename(xid, pTcon, fromName,
						   toName,
1161 1162 1163
						   cifs_sb_source->local_nls,
						   cifs_sb_source->mnt_cifs_flags
						   & CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168
			}
			kfree(info_buf_source);
		} /* if we can not get memory just leave rc as EEXIST */
	}

S
Steve French 已提交
1169
	if (rc)
L
Linus Torvalds 已提交
1170 1171 1172
		cFYI(1, ("rename rc %d", rc));

	if ((rc == -EIO) || (rc == -EEXIST)) {
1173
		int oplock = 0;
L
Linus Torvalds 已提交
1174 1175 1176 1177 1178 1179 1180 1181
		__u16 netfid;

		/* BB FIXME Is Generic Read correct for rename? */
		/* if renaming directory - we should not say CREATE_NOT_DIR,
		   need to test renaming open directory, also GENERIC_READ
		   might not right be right access to request */
		rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
				 CREATE_NOT_DIR, &netfid, &oplock, NULL,
S
Steve French 已提交
1182 1183
				 cifs_sb_source->local_nls,
				 cifs_sb_source->mnt_cifs_flags &
1184
					CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
1185
		if (rc == 0) {
1186
			rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
S
Steve French 已提交
1187
					      cifs_sb_source->local_nls,
1188 1189
					      cifs_sb_source->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
			CIFSSMBClose(xid, pTcon, netfid);
		}
	}

cifs_rename_exit:
	kfree(fromName);
	kfree(toName);
	FreeXid(xid);
	return rc;
}

int cifs_revalidate(struct dentry *direntry)
{
	int xid;
1204
	int rc = 0, wbrc = 0;
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209
	char *full_path;
	struct cifs_sb_info *cifs_sb;
	struct cifsInodeInfo *cifsInode;
	loff_t local_size;
	struct timespec local_mtime;
1210
	bool invalidate_inode = false;
L
Linus Torvalds 已提交
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229

	if (direntry->d_inode == NULL)
		return -ENOENT;

	cifsInode = CIFS_I(direntry->d_inode);

	if (cifsInode == NULL)
		return -ENOENT;

	/* no sense revalidating inode info on file that no one can write */
	if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
		return rc;

	xid = GetXid();

	cifs_sb = CIFS_SB(direntry->d_sb);

	/* can not safely grab the rename sem here if rename calls revalidate
	   since that would deadlock */
1230
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
	cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
		 "jiffies %ld", full_path, direntry->d_inode,
		 direntry->d_inode->i_count.counter, direntry,
		 direntry->d_time, jiffies));

	if (cifsInode->time == 0) {
		/* was set to zero previously to force revalidate */
	} else if (time_before(jiffies, cifsInode->time + HZ) &&
		   lookupCacheEnabled) {
		if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
		    (direntry->d_inode->i_nlink == 1)) {
			kfree(full_path);
			FreeXid(xid);
			return rc;
		} else {
			cFYI(1, ("Have to revalidate file due to hardlinks"));
		}
	}

	/* save mtime and size */
	local_mtime = direntry->d_inode->i_mtime;
	local_size = direntry->d_inode->i_size;

1258
	if (cifs_sb->tcon->unix_ext) {
L
Linus Torvalds 已提交
1259
		rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
S
Steve French 已提交
1260
					      direntry->d_sb, xid);
L
Linus Torvalds 已提交
1261 1262 1263 1264 1265 1266 1267 1268
		if (rc) {
			cFYI(1, ("error on getting revalidate info %d", rc));
/*			if (rc != -ENOENT)
				rc = 0; */	/* BB should we cache info on
						   certain errors? */
		}
	} else {
		rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
1269
					 direntry->d_sb, xid, NULL);
L
Linus Torvalds 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
		if (rc) {
			cFYI(1, ("error on getting revalidate info %d", rc));
/*			if (rc != -ENOENT)
				rc = 0; */	/* BB should we cache info on
						   certain errors? */
		}
	}
	/* should we remap certain errors, access denied?, to zero */

	/* if not oplocked, we invalidate inode pages if mtime or file size
	   had changed on server */

S
Steve French 已提交
1282
	if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
L
Linus Torvalds 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291
	    (local_size == direntry->d_inode->i_size)) {
		cFYI(1, ("cifs_revalidate - inode unchanged"));
	} else {
		/* file may have changed on server */
		if (cifsInode->clientCanCacheRead) {
			/* no need to invalidate inode pages since we were the
			   only ones who could have modified the file and the
			   server copy is staler than ours */
		} else {
1292
			invalidate_inode = true;
L
Linus Torvalds 已提交
1293 1294 1295 1296
		}
	}

	/* can not grab this sem since kernel filesys locking documentation
1297 1298 1299
	   indicates i_mutex may be taken by the kernel on lookup and rename
	   which could deadlock if we grab the i_mutex here as well */
/*	mutex_lock(&direntry->d_inode->i_mutex);*/
L
Linus Torvalds 已提交
1300 1301 1302 1303
	/* need to write out dirty pages here  */
	if (direntry->d_inode->i_mapping) {
		/* do we need to lock inode until after invalidate completes
		   below? */
1304 1305 1306
		wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
		if (wbrc)
			CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
L
Linus Torvalds 已提交
1307 1308
	}
	if (invalidate_inode) {
1309 1310
	/* shrink_dcache not necessary now that cifs dentry ops
	are exported for negative dentries */
S
Steve French 已提交
1311
/*		if (S_ISDIR(direntry->d_inode->i_mode))
1312 1313 1314
			shrink_dcache_parent(direntry); */
		if (S_ISREG(direntry->d_inode->i_mode)) {
			if (direntry->d_inode->i_mapping)
1315 1316 1317
				wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
				if (wbrc)
					CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1318 1319 1320 1321 1322 1323 1324
			/* may eventually have to do this for open files too */
			if (list_empty(&(cifsInode->openFileList))) {
				/* changed on server - flush read ahead pages */
				cFYI(1, ("Invalidating read ahead data on "
					 "closed file"));
				invalidate_remote_inode(direntry->d_inode);
			}
L
Linus Torvalds 已提交
1325 1326
		}
	}
1327
/*	mutex_unlock(&direntry->d_inode->i_mutex); */
1328

L
Linus Torvalds 已提交
1329 1330 1331 1332 1333 1334 1335 1336 1337
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
	struct kstat *stat)
{
	int err = cifs_revalidate(dentry);
S
Steve French 已提交
1338
	if (!err) {
L
Linus Torvalds 已提交
1339
		generic_fillattr(dentry->d_inode, stat);
S
Steve French 已提交
1340 1341
		stat->blksize = CIFS_MAX_MSGSIZE;
	}
L
Linus Torvalds 已提交
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	return err;
}

static int cifs_truncate_page(struct address_space *mapping, loff_t from)
{
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE - 1);
	struct page *page;
	int rc = 0;

	page = grab_cache_page(mapping, index);
	if (!page)
		return -ENOMEM;

1356
	zero_user_segment(page, offset, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361
	unlock_page(page);
	page_cache_release(page);
	return rc;
}

S
Steve French 已提交
1362
static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1363 1364 1365 1366
{
	struct address_space *mapping = inode->i_mapping;
	unsigned long limit;

1367
	spin_lock(&inode->i_lock);
1368 1369 1370 1371 1372 1373
	if (inode->i_size < offset)
		goto do_expand;
	/*
	 * truncation of in-use swapfiles is disallowed - it would cause
	 * subsequent swapout to scribble on the now-freed blocks.
	 */
1374 1375
	if (IS_SWAPFILE(inode)) {
		spin_unlock(&inode->i_lock);
1376
		goto out_busy;
1377
	}
1378 1379
	i_size_write(inode, offset);
	spin_unlock(&inode->i_lock);
1380 1381 1382 1383 1384 1385 1386 1387
	/*
	 * unmap_mapping_range is called twice, first simply for efficiency
	 * so that truncate_inode_pages does fewer single-page unmaps. However
	 * after this first call, and before truncate_inode_pages finishes,
	 * it is possible for private pages to be COWed, which remain after
	 * truncate_inode_pages finishes, hence the second unmap_mapping_range
	 * call must be made for correctness.
	 */
1388 1389
	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
	truncate_inode_pages(mapping, offset);
1390
	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1391 1392 1393 1394
	goto out_truncate;

do_expand:
	limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1395 1396
	if (limit != RLIM_INFINITY && offset > limit) {
		spin_unlock(&inode->i_lock);
1397
		goto out_sig;
1398 1399 1400
	}
	if (offset > inode->i_sb->s_maxbytes) {
		spin_unlock(&inode->i_lock);
1401
		goto out_big;
1402
	}
1403
	i_size_write(inode, offset);
1404
	spin_unlock(&inode->i_lock);
1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
out_truncate:
	if (inode->i_op && inode->i_op->truncate)
		inode->i_op->truncate(inode);
	return 0;
out_sig:
	send_sig(SIGXFSZ, current, 0);
out_big:
	return -EFBIG;
out_busy:
	return -ETXTBSY;
}

L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422 1423 1424 1425
int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
{
	int xid;
	struct cifs_sb_info *cifs_sb;
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	int rc = -EACCES;
	struct cifsFileInfo *open_file = NULL;
	FILE_BASIC_INFO time_buf;
1426 1427
	bool set_time = false;
	bool set_dosattr = false;
L
Linus Torvalds 已提交
1428 1429 1430 1431
	__u64 mode = 0xFFFFFFFFFFFFFFFFULL;
	__u64 uid = 0xFFFFFFFFFFFFFFFFULL;
	__u64 gid = 0xFFFFFFFFFFFFFFFFULL;
	struct cifsInodeInfo *cifsInode;
1432
	struct inode *inode = direntry->d_inode;
L
Linus Torvalds 已提交
1433 1434 1435

	xid = GetXid();

1436
	cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
L
Linus Torvalds 已提交
1437
		 direntry->d_name.name, attrs->ia_valid));
1438

1439
	cifs_sb = CIFS_SB(inode->i_sb);
L
Linus Torvalds 已提交
1440 1441
	pTcon = cifs_sb->tcon;

1442
	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1443
		/* check if we have permission to change attrs */
1444
		rc = inode_change_ok(inode, attrs);
S
Steve French 已提交
1445
		if (rc < 0) {
1446 1447 1448 1449 1450
			FreeXid(xid);
			return rc;
		} else
			rc = 0;
	}
1451

1452
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
1453 1454 1455 1456
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
1457
	cifsInode = CIFS_I(inode);
L
Linus Torvalds 已提交
1458

1459
	if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
1460
		/*
1461 1462
		   Flush data before changing file size or changing the last
		   write time of the file on the server. If the
1463 1464 1465 1466 1467
		   flush returns error, store it to report later and continue.
		   BB: This should be smarter. Why bother flushing pages that
		   will be truncated anyway? Also, should we error out here if
		   the flush returns error?
		 */
1468
		rc = filemap_write_and_wait(inode->i_mapping);
1469
		if (rc != 0) {
1470
			cifsInode->write_behind_rc = rc;
1471 1472
			rc = 0;
		}
1473
	}
1474

1475
	if (attrs->ia_valid & ATTR_SIZE) {
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480 1481 1482
		/* To avoid spurious oplock breaks from server, in the case of
		   inodes that we already have open, avoid doing path based
		   setting of file size if we can do it by handle.
		   This keeps our caching token (oplock) and avoids timeouts
		   when the local oplock break takes longer to flush
		   writebehind data than the SMB timeout for the SetPathInfo
		   request would allow */
1483

1484 1485 1486 1487 1488
		open_file = find_writable_file(cifsInode);
		if (open_file) {
			__u16 nfid = open_file->netfid;
			__u32 npid = open_file->pid;
			rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
1489
						nfid, npid, false);
1490
			atomic_dec(&open_file->wrtPending);
S
Steve French 已提交
1491 1492
			cFYI(1, ("SetFSize for attrs rc = %d", rc));
			if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1493
				unsigned int bytes_written;
1494 1495 1496 1497
				rc = CIFSSMBWrite(xid, pTcon,
						  nfid, 0, attrs->ia_size,
						  &bytes_written, NULL, NULL,
						  1 /* 45 seconds */);
S
Steve French 已提交
1498
				cFYI(1, ("Wrt seteof rc %d", rc));
L
Linus Torvalds 已提交
1499
			}
S
Steve French 已提交
1500
		} else
1501 1502
			rc = -EINVAL;

L
Linus Torvalds 已提交
1503 1504 1505 1506 1507 1508
		if (rc != 0) {
			/* Set file size by pathname rather than by handle
			   either because no valid, writeable file handle for
			   it was found or because there was an error setting
			   it by handle */
			rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1509
					   attrs->ia_size, false,
S
Steve French 已提交
1510
					   cifs_sb->local_nls,
1511 1512
					   cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
1513
			cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
S
Steve French 已提交
1514
			if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1515
				__u16 netfid;
1516
				int oplock = 0;
1517 1518

				rc = SMBLegacyOpen(xid, pTcon, full_path,
1519
					FILE_OPEN, GENERIC_WRITE,
1520 1521 1522 1523
					CREATE_NOT_DIR, &netfid, &oplock,
					NULL, cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
1524
				if (rc == 0) {
1525
					unsigned int bytes_written;
1526 1527 1528 1529 1530
					rc = CIFSSMBWrite(xid, pTcon,
							netfid, 0,
							attrs->ia_size,
							&bytes_written, NULL,
							NULL, 1 /* 45 sec */);
S
Steve French 已提交
1531
					cFYI(1, ("wrt seteof rc %d", rc));
1532 1533 1534 1535
					CIFSSMBClose(xid, pTcon, netfid);
				}

			}
L
Linus Torvalds 已提交
1536 1537 1538 1539
		}

		/* Server is ok setting allocation size implicitly - no need
		   to call:
1540
		CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, true,
L
Linus Torvalds 已提交
1541 1542 1543 1544
			 cifs_sb->local_nls);
		   */

		if (rc == 0) {
1545 1546
			rc = cifs_vmtruncate(inode, attrs->ia_size);
			cifs_truncate_page(inode->i_mapping, inode->i_size);
S
Steve French 已提交
1547
		} else
1548
			goto cifs_setattr_exit;
L
Linus Torvalds 已提交
1549 1550
	}
	if (attrs->ia_valid & ATTR_UID) {
1551
		cFYI(1, ("UID changed to %d", attrs->ia_uid));
L
Linus Torvalds 已提交
1552 1553 1554
		uid = attrs->ia_uid;
	}
	if (attrs->ia_valid & ATTR_GID) {
1555
		cFYI(1, ("GID changed to %d", attrs->ia_gid));
L
Linus Torvalds 已提交
1556 1557 1558 1559
		gid = attrs->ia_gid;
	}

	time_buf.Attributes = 0;
1560 1561 1562 1563 1564

	/* skip mode change if it's just for clearing setuid/setgid */
	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
		attrs->ia_valid &= ~ATTR_MODE;

L
Linus Torvalds 已提交
1565
	if (attrs->ia_valid & ATTR_MODE) {
1566
		cFYI(1, ("Mode changed to 0x%x", attrs->ia_mode));
L
Linus Torvalds 已提交
1567 1568 1569
		mode = attrs->ia_mode;
	}

1570
	if ((pTcon->unix_ext)
L
Linus Torvalds 已提交
1571 1572
	    && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
		rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1573
					 0 /* dev_t */, cifs_sb->local_nls,
S
Steve French 已提交
1574
					 cifs_sb->mnt_cifs_flags &
1575
						CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1576
	else if (attrs->ia_valid & ATTR_MODE) {
1577
		rc = 0;
1578 1579
#ifdef CONFIG_CIFS_EXPERIMENTAL
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1580
			rc = mode_to_acl(inode, full_path, mode);
1581
		else if ((mode & S_IWUGO) == 0) {
1582
#else
1583
		if ((mode & S_IWUGO) == 0) {
1584
#endif
1585
			/* not writeable */
1586
			if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1587
				set_dosattr = true;
L
Linus Torvalds 已提交
1588 1589 1590
				time_buf.Attributes =
					cpu_to_le32(cifsInode->cifsAttrs |
						    ATTR_READONLY);
1591
			}
1592 1593 1594 1595 1596
		} else if (cifsInode->cifsAttrs & ATTR_READONLY) {
			/* If file is readonly on server, we would
			not be able to write to it - so if any write
			bit is enabled for user or group or other we
			need to at least try to remove r/o dos attr */
1597
			set_dosattr = true;
1598 1599 1600
			time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
					    (~ATTR_READONLY));
			/* Windows ignores set to zero */
S
Steve French 已提交
1601
			if (time_buf.Attributes == 0)
1602
				time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
L
Linus Torvalds 已提交
1603 1604 1605 1606
		}
	}

	if (attrs->ia_valid & ATTR_ATIME) {
1607
		set_time = true;
L
Linus Torvalds 已提交
1608 1609 1610 1611 1612 1613
		time_buf.LastAccessTime =
		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
	} else
		time_buf.LastAccessTime = 0;

	if (attrs->ia_valid & ATTR_MTIME) {
1614
		set_time = true;
L
Linus Torvalds 已提交
1615 1616 1617 1618
		time_buf.LastWriteTime =
		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
	} else
		time_buf.LastWriteTime = 0;
1619 1620 1621 1622
	/* Do not set ctime explicitly unless other time
	   stamps are changed explicitly (i.e. by utime()
	   since we would then have a mix of client and
	   server times */
1623

1624
	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1625
		set_time = true;
1626 1627 1628 1629
		/* Although Samba throws this field away
		it may be useful to Windows - but we do
		not want to set ctime unless some other
		timestamp is changing */
1630
		cFYI(1, ("CIFS - CTIME changed"));
L
Linus Torvalds 已提交
1631 1632 1633 1634 1635
		time_buf.ChangeTime =
		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
	} else
		time_buf.ChangeTime = 0;

1636
	if (set_time || set_dosattr) {
L
Linus Torvalds 已提交
1637 1638 1639 1640 1641
		time_buf.CreationTime = 0;	/* do not change */
		/* In the future we should experiment - try setting timestamps
		   via Handle (SetFileInfo) instead of by path */
		if (!(pTcon->ses->flags & CIFS_SES_NT4))
			rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1642 1643 1644
					     cifs_sb->local_nls,
					     cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1645 1646 1647 1648
		else
			rc = -EOPNOTSUPP;

		if (rc == -EOPNOTSUPP) {
1649
			int oplock = 0;
L
Linus Torvalds 已提交
1650 1651 1652 1653 1654 1655 1656 1657 1658
			__u16 netfid;

			cFYI(1, ("calling SetFileInfo since SetPathInfo for "
				 "times not supported by this server"));
			/* BB we could scan to see if we already have it open
			   and pass in pid of opener to function */
			rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
					 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
					 CREATE_NOT_DIR, &netfid, &oplock,
1659 1660 1661
					 NULL, cifs_sb->local_nls,
					 cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
1662
			if (rc == 0) {
L
Linus Torvalds 已提交
1663 1664 1665 1666 1667 1668 1669 1670 1671
				rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
							 netfid);
				CIFSSMBClose(xid, pTcon, netfid);
			} else {
			/* BB For even older servers we could convert time_buf
			   into old DOS style which uses two second
			   granularity */

			/* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
S
Steve French 已提交
1672
					&time_buf, cifs_sb->local_nls); */
L
Linus Torvalds 已提交
1673 1674
			}
		}
1675 1676 1677 1678 1679
		/* Even if error on time set, no sense failing the call if
		the server would set the time to a reasonable value anyway,
		and this check ensures that we are not being called from
		sys_utimes in which case we ought to fail the call back to
		the user when the server rejects the call */
S
Steve French 已提交
1680
		if ((rc) && (attrs->ia_valid &
1681 1682
			 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
			rc = 0;
L
Linus Torvalds 已提交
1683 1684 1685 1686 1687
	}

	/* do not need local check to inode_check_ok since the server does
	   that */
	if (!rc)
1688
		rc = inode_setattr(inode, attrs);
1689
cifs_setattr_exit:
L
Linus Torvalds 已提交
1690 1691 1692 1693 1694
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

1695
#if 0
L
Linus Torvalds 已提交
1696 1697
void cifs_delete_inode(struct inode *inode)
{
1698
	cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
L
Linus Torvalds 已提交
1699 1700 1701
	/* may have to add back in if and when safe distributed caching of
	   directories added e.g. via FindNotify */
}
1702
#endif