inode.c 58.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *   fs/cifs/inode.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2010
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *   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>
23
#include <linux/slab.h>
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31
#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
#include "fscache.h"
L
Linus Torvalds 已提交
33

34

35
static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
{
	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 */
55
		if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
56 57 58 59 60 61
				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 已提交
62
#ifdef CONFIG_CIFS_DFS_UPCALL
63 64 65
		if (is_dfs_referral) {
			inode->i_op = &cifs_dfs_referral_inode_operations;
		} else {
S
Steve French 已提交
66 67 68
#else /* NO DFS support, treat as a directory */
		{
#endif
69 70 71
			inode->i_op = &cifs_dir_inode_ops;
			inode->i_fop = &cifs_dir_ops;
		}
72 73 74 75 76 77 78 79 80 81
		break;
	case S_IFLNK:
		inode->i_op = &cifs_symlink_inode_ops;
		break;
	default:
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
		break;
	}
}

82 83 84 85 86 87 88 89
/* check inode attributes against fattr. If they don't match, tag the
 * inode for cache invalidation
 */
static void
cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
{
	struct cifsInodeInfo *cifs_i = CIFS_I(inode);

90
	cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
91 92

	if (inode->i_state & I_NEW) {
93
		cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
94 95 96 97 98
		return;
	}

	/* don't bother with revalidation if we have an oplock */
	if (cifs_i->clientCanCacheRead) {
99 100
		cFYI(1, "%s: inode %llu is oplocked", __func__,
			 cifs_i->uniqueid);
101 102 103 104 105 106
		return;
	}

	 /* revalidate if mtime or size have changed */
	if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
	    cifs_i->server_eof == fattr->cf_eof) {
107 108
		cFYI(1, "%s: inode %llu is unchanged", __func__,
			 cifs_i->uniqueid);
109 110 111
		return;
	}

112 113
	cFYI(1, "%s: invalidating inode %llu mapping", __func__,
		 cifs_i->uniqueid);
114 115 116
	cifs_i->invalid_mapping = true;
}

117 118 119
/* populate an inode with info from a cifs_fattr struct */
void
cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
120
{
121
	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
122 123
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
	unsigned long oldtime = cifs_i->time;
124

125 126
	cifs_revalidate_cache(inode, fattr);

127 128 129 130 131 132 133 134
	inode->i_atime = fattr->cf_atime;
	inode->i_mtime = fattr->cf_mtime;
	inode->i_ctime = fattr->cf_ctime;
	inode->i_rdev = fattr->cf_rdev;
	inode->i_nlink = fattr->cf_nlink;
	inode->i_uid = fattr->cf_uid;
	inode->i_gid = fattr->cf_gid;

135 136 137 138 139
	/* if dynperm is set, don't clobber existing mode */
	if (inode->i_state & I_NEW ||
	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
		inode->i_mode = fattr->cf_mode;

140
	cifs_i->cifsAttrs = fattr->cf_cifsattrs;
141

142 143 144 145 146
	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
		cifs_i->time = 0;
	else
		cifs_i->time = jiffies;

147 148
	cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
		 oldtime, cifs_i->time);
149 150

	cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
151

152
	cifs_i->server_eof = fattr->cf_eof;
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
	/*
	 * Can't safely change the file size here if the client is writing to
	 * it due to potential races.
	 */
	spin_lock(&inode->i_lock);
	if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
		i_size_write(inode, fattr->cf_eof);

		/*
		 * 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 + fattr->cf_bytes) >> 9;
	}
	spin_unlock(&inode->i_lock);

	cifs_set_ops(inode, fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL);
}

173 174 175 176 177 178 179 180 181 182 183
void
cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
{
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
		return;

	fattr->cf_uniqueid = iunique(sb, ROOT_I);
}

184 185 186 187 188 189 190 191 192 193 194 195 196 197
/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
void
cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
			 struct cifs_sb_info *cifs_sb)
{
	memset(fattr, 0, sizeof(*fattr));
	fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
	fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
	fattr->cf_eof = le64_to_cpu(info->EndOfFile);

	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
	fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
	fattr->cf_mode = le64_to_cpu(info->Permissions);
198 199 200 201 202

	/*
	 * Since we set the inode type below we need to mask off
	 * to avoid strange results if bits set above.
	 */
203
	fattr->cf_mode &= ~S_IFMT;
204 205
	switch (le32_to_cpu(info->Type)) {
	case UNIX_FILE:
206 207
		fattr->cf_mode |= S_IFREG;
		fattr->cf_dtype = DT_REG;
208 209
		break;
	case UNIX_SYMLINK:
210 211
		fattr->cf_mode |= S_IFLNK;
		fattr->cf_dtype = DT_LNK;
212 213
		break;
	case UNIX_DIR:
214 215
		fattr->cf_mode |= S_IFDIR;
		fattr->cf_dtype = DT_DIR;
216 217
		break;
	case UNIX_CHARDEV:
218 219 220 221
		fattr->cf_mode |= S_IFCHR;
		fattr->cf_dtype = DT_CHR;
		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
				       le64_to_cpu(info->DevMinor) & MINORMASK);
222 223
		break;
	case UNIX_BLOCKDEV:
224 225 226 227
		fattr->cf_mode |= S_IFBLK;
		fattr->cf_dtype = DT_BLK;
		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
				       le64_to_cpu(info->DevMinor) & MINORMASK);
228 229
		break;
	case UNIX_FIFO:
230 231
		fattr->cf_mode |= S_IFIFO;
		fattr->cf_dtype = DT_FIFO;
232 233
		break;
	case UNIX_SOCKET:
234 235
		fattr->cf_mode |= S_IFSOCK;
		fattr->cf_dtype = DT_SOCK;
236 237 238
		break;
	default:
		/* safest to call it a file if we do not know */
239 240
		fattr->cf_mode |= S_IFREG;
		fattr->cf_dtype = DT_REG;
241
		cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
242 243 244
		break;
	}

245 246
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
		fattr->cf_uid = cifs_sb->mnt_uid;
247
	else
248
		fattr->cf_uid = le64_to_cpu(info->Uid);
249

250 251
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
		fattr->cf_gid = cifs_sb->mnt_gid;
252
	else
253
		fattr->cf_gid = le64_to_cpu(info->Gid);
254

255
	fattr->cf_nlink = le64_to_cpu(info->Nlinks);
256 257
}

258
/*
259 260 261 262 263
 * Fill a cifs_fattr struct with fake inode info.
 *
 * Needed to setup cifs_fattr data for the directory which is the
 * junction to the new submount (ie to setup the fake directory
 * which represents a DFS referral).
264
 */
S
Steve French 已提交
265
static void
266
cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
267
{
268
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
269

270
	cFYI(1, "creating fake fattr for DFS referral");
271 272 273 274 275 276 277 278 279 280

	memset(fattr, 0, sizeof(*fattr));
	fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
	fattr->cf_uid = cifs_sb->mnt_uid;
	fattr->cf_gid = cifs_sb->mnt_gid;
	fattr->cf_atime = CURRENT_TIME;
	fattr->cf_ctime = CURRENT_TIME;
	fattr->cf_mtime = CURRENT_TIME;
	fattr->cf_nlink = 2;
	fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
281 282
}

J
Jeff Layton 已提交
283 284 285 286 287 288 289 290
int cifs_get_file_info_unix(struct file *filp)
{
	int rc;
	int xid;
	FILE_UNIX_BASIC_INFO find_data;
	struct cifs_fattr fattr;
	struct inode *inode = filp->f_path.dentry->d_inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
291
	struct cifsFileInfo *cfile = filp->private_data;
292
	struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
J
Jeff Layton 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307

	xid = GetXid();
	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
	if (!rc) {
		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
	} else if (rc == -EREMOTE) {
		cifs_create_dfs_fattr(&fattr, inode->i_sb);
		rc = 0;
	}

	cifs_fattr_to_inode(inode, &fattr);
	FreeXid(xid);
	return rc;
}

L
Linus Torvalds 已提交
308
int cifs_get_inode_info_unix(struct inode **pinode,
309 310
			     const unsigned char *full_path,
			     struct super_block *sb, int xid)
L
Linus Torvalds 已提交
311
{
312
	int rc;
313
	FILE_UNIX_BASIC_INFO find_data;
314 315
	struct cifs_fattr fattr;
	struct cifsTconInfo *tcon;
316
	struct tcon_link *tlink;
L
Linus Torvalds 已提交
317 318
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

319
	cFYI(1, "Getting info on %s", full_path);
320

321 322 323 324 325
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);

L
Linus Torvalds 已提交
326
	/* could have done a find first instead but this returns more info */
327
	rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
328 329
				  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
330
	cifs_put_tlink(tlink);
331

332 333 334 335 336 337 338 339
	if (!rc) {
		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
	} else if (rc == -EREMOTE) {
		cifs_create_dfs_fattr(&fattr, sb);
		rc = 0;
	} else {
		return rc;
	}
L
Linus Torvalds 已提交
340

341 342 343 344 345 346 347
	/* check for Minshall+French symlinks */
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
		int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
		if (tmprc)
			cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
	}

348
	if (*pinode == NULL) {
349
		/* get new inode */
350
		cifs_fill_uniqueid(sb, &fattr);
351 352
		*pinode = cifs_iget(sb, &fattr);
		if (!*pinode)
353
			rc = -ENOMEM;
354 355 356
	} else {
		/* we already have inode, update it */
		cifs_fattr_to_inode(*pinode, &fattr);
357
	}
L
Linus Torvalds 已提交
358 359 360 361

	return rc;
}

362 363 364
static int
cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
	      struct cifs_sb_info *cifs_sb, int xid)
365 366
{
	int rc;
367
	int oplock = 0;
368
	__u16 netfid;
369 370
	struct tcon_link *tlink;
	struct cifsTconInfo *tcon;
371
	char buf[24];
372
	unsigned int bytes_read;
S
Steve French 已提交
373
	char *pbuf;
374 375 376

	pbuf = buf;

377 378 379 380 381
	fattr->cf_mode &= ~S_IFMT;

	if (fattr->cf_eof == 0) {
		fattr->cf_mode |= S_IFIFO;
		fattr->cf_dtype = DT_FIFO;
382
		return 0;
383 384 385
	} else if (fattr->cf_eof < 8) {
		fattr->cf_mode |= S_IFREG;
		fattr->cf_dtype = DT_REG;
386 387
		return -EINVAL;	 /* EOPNOTSUPP? */
	}
388

389 390 391 392 393 394
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);

	rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
395 396 397 398
			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
			 cifs_sb->local_nls,
			 cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
399
	if (rc == 0) {
400
		int buf_type = CIFS_NO_BUFFER;
401
			/* Read header */
402
		rc = CIFSSMBRead(xid, tcon, netfid,
403
				 24 /* length */, 0 /* offset */,
404
				 &bytes_read, &pbuf, &buf_type);
405 406
		if ((rc == 0) && (bytes_read >= 8)) {
			if (memcmp("IntxBLK", pbuf, 8) == 0) {
407
				cFYI(1, "Block device");
408 409
				fattr->cf_mode |= S_IFBLK;
				fattr->cf_dtype = DT_BLK;
410
				if (bytes_read == 24) {
411 412 413 414 415
					/* 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));
416
					fattr->cf_rdev = MKDEV(mjr, mnr);
417
				}
418
			} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
419
				cFYI(1, "Char device");
420 421
				fattr->cf_mode |= S_IFCHR;
				fattr->cf_dtype = DT_CHR;
422
				if (bytes_read == 24) {
423 424 425 426 427
					/* 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));
428
					fattr->cf_rdev = MKDEV(mjr, mnr);
S
Steve French 已提交
429
				}
430
			} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
431
				cFYI(1, "Symlink");
432 433
				fattr->cf_mode |= S_IFLNK;
				fattr->cf_dtype = DT_LNK;
434
			} else {
435 436
				fattr->cf_mode |= S_IFREG; /* file? */
				fattr->cf_dtype = DT_REG;
S
Steve French 已提交
437
				rc = -EOPNOTSUPP;
438
			}
439
		} else {
440 441
			fattr->cf_mode |= S_IFREG; /* then it is a file */
			fattr->cf_dtype = DT_REG;
S
Steve French 已提交
442 443
			rc = -EOPNOTSUPP; /* or some unknown SFU type */
		}
444
		CIFSSMBClose(xid, tcon, netfid);
445
	}
446
	cifs_put_tlink(tlink);
447 448 449
	return rc;
}

450 451
#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */

452 453 454 455 456 457 458
/*
 * Fetch mode bits as provided by SFU.
 *
 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
 */
static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
			 struct cifs_sb_info *cifs_sb, int xid)
459
{
460
#ifdef CONFIG_CIFS_XATTR
461 462 463
	ssize_t rc;
	char ea_value[4];
	__u32 mode;
464 465 466 467 468 469 470
	struct tcon_link *tlink;
	struct cifsTconInfo *tcon;

	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);
471

472
	rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
473 474 475
			    ea_value, 4 /* size of buf */, cifs_sb->local_nls,
			    cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);
476
	cifs_put_tlink(tlink);
477
	if (rc < 0)
478 479 480
		return (int)rc;
	else if (rc > 3) {
		mode = le32_to_cpu(*((__le32 *)ea_value));
481
		fattr->cf_mode &= ~SFBITS_MASK;
482 483
		cFYI(1, "special bits 0%o org mode 0%o", mode,
			 fattr->cf_mode);
484
		fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
485
		cFYI(1, "special mode bits 0%o", mode);
486
	}
487 488

	return 0;
489 490 491
#else
	return -EOPNOTSUPP;
#endif
492 493
}

494
/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
S
Steve French 已提交
495
static void
496 497
cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
		       struct cifs_sb_info *cifs_sb, bool adjust_tz)
498
{
499 500
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);

501 502 503 504 505 506 507 508 509 510 511 512 513 514
	memset(fattr, 0, sizeof(*fattr));
	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
	if (info->DeletePending)
		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;

	if (info->LastAccessTime)
		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
	else
		fattr->cf_atime = CURRENT_TIME;

	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);

	if (adjust_tz) {
515 516
		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
517 518 519 520 521 522 523 524 525 526 527 528
	}

	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);

	if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
		fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
		fattr->cf_dtype = DT_DIR;
	} else {
		fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
		fattr->cf_dtype = DT_REG;

529 530 531 532
		/* clear write bits if ATTR_READONLY is set */
		if (fattr->cf_cifsattrs & ATTR_READONLY)
			fattr->cf_mode &= ~(S_IWUGO);
	}
533 534 535 536 537

	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);

	fattr->cf_uid = cifs_sb->mnt_uid;
	fattr->cf_gid = cifs_sb->mnt_gid;
538 539
}

J
Jeff Layton 已提交
540 541 542 543 544 545 546 547
int cifs_get_file_info(struct file *filp)
{
	int rc;
	int xid;
	FILE_ALL_INFO find_data;
	struct cifs_fattr fattr;
	struct inode *inode = filp->f_path.dentry->d_inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
548
	struct cifsFileInfo *cfile = filp->private_data;
549
	struct cifsTconInfo *tcon = tlink_tcon(cfile->tlink);
J
Jeff Layton 已提交
550 551 552 553 554 555

	xid = GetXid();
	rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
	if (rc == -EOPNOTSUPP || rc == -EINVAL) {
		/*
		 * FIXME: legacy server -- fall back to path-based call?
S
Steve French 已提交
556 557 558
		 * for now, just skip revalidating and mark inode for
		 * immediate reval.
		 */
J
Jeff Layton 已提交
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
		rc = 0;
		CIFS_I(inode)->time = 0;
		goto cgfi_exit;
	} else if (rc == -EREMOTE) {
		cifs_create_dfs_fattr(&fattr, inode->i_sb);
		rc = 0;
	} else if (rc)
		goto cgfi_exit;

	/*
	 * don't bother with SFU junk here -- just mark inode as needing
	 * revalidation.
	 */
	cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
	fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
	fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
	cifs_fattr_to_inode(inode, &fattr);
cgfi_exit:
	FreeXid(xid);
	return rc;
}

L
Linus Torvalds 已提交
581
int cifs_get_inode_info(struct inode **pinode,
582
	const unsigned char *full_path, FILE_ALL_INFO *pfindData,
583
	struct super_block *sb, int xid, const __u16 *pfid)
L
Linus Torvalds 已提交
584
{
585
	int rc = 0, tmprc;
L
Linus Torvalds 已提交
586
	struct cifsTconInfo *pTcon;
587
	struct tcon_link *tlink;
L
Linus Torvalds 已提交
588 589
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	char *buf = NULL;
S
Steve French 已提交
590
	bool adjustTZ = false;
591
	struct cifs_fattr fattr;
L
Linus Torvalds 已提交
592

593 594 595 596 597
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

598
	cFYI(1, "Getting info on %s", full_path);
L
Linus Torvalds 已提交
599

600 601
	if ((pfindData == NULL) && (*pinode != NULL)) {
		if (CIFS_I(*pinode)->clientCanCacheRead) {
602
			cFYI(1, "No need to revalidate cached inode sizes");
603
			goto cgii_exit;
L
Linus Torvalds 已提交
604 605 606 607
		}
	}

	/* if file info not passed in then get it from server */
608
	if (pfindData == NULL) {
L
Linus Torvalds 已提交
609
		buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
610 611 612 613
		if (buf == NULL) {
			rc = -ENOMEM;
			goto cgii_exit;
		}
L
Linus Torvalds 已提交
614
		pfindData = (FILE_ALL_INFO *)buf;
615

L
Linus Torvalds 已提交
616
		/* could do find first instead but this returns more info */
617
		rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
618
			      0 /* not legacy */,
619
			      cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
620
				CIFS_MOUNT_MAP_SPECIAL_CHR);
621 622 623
		/* 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 */
624
		if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
625
			rc = SMBQueryInformation(xid, pTcon, full_path,
S
Steve French 已提交
626
					pfindData, cifs_sb->local_nls,
627 628
					cifs_sb->mnt_cifs_flags &
					  CIFS_MOUNT_MAP_SPECIAL_CHR);
629
			adjustTZ = true;
630
		}
L
Linus Torvalds 已提交
631
	}
632 633 634 635 636 637

	if (!rc) {
		cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
				       cifs_sb, adjustTZ);
	} else if (rc == -EREMOTE) {
		cifs_create_dfs_fattr(&fattr, sb);
638
		rc = 0;
639
	} else {
640
		goto cgii_exit;
641
	}
L
Linus Torvalds 已提交
642

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
	/*
	 * If an inode wasn't passed in, then get the inode number
	 *
	 * 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. The SNIA
	 * CIFS spec claims that this value is unique within the scope of a
	 * share, and the windows docs hint that it's actually unique
	 * per-machine.
	 *
	 * There may be higher info levels that work but are there Windows
	 * server or network appliances for which IndexNumber field is not
	 * guaranteed unique?
	 */
660 661 662 663 664
	if (*pinode == NULL) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
			int rc1 = 0;

			rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
665
					full_path, &fattr.cf_uniqueid,
666 667 668
					cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
669
			if (rc1 || !fattr.cf_uniqueid) {
670
				cFYI(1, "GetSrvInodeNum rc %d", rc1);
671
				fattr.cf_uniqueid = iunique(sb, ROOT_I);
672
				cifs_autodisable_serverino(cifs_sb);
673 674
			}
		} else {
675
			fattr.cf_uniqueid = iunique(sb, ROOT_I);
676
		}
677
	} else {
678
		fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
679 680
	}

681 682 683 684 685
	/* query for SFU type info if supported and needed */
	if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
		tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
		if (tmprc)
686
			cFYI(1, "cifs_sfu_type failed: %d", tmprc);
687
	}
L
Linus Torvalds 已提交
688

S
Steve French 已提交
689
#ifdef CONFIG_CIFS_EXPERIMENTAL
690 691
	/* fill in 0777 bits from ACL */
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
692
		cFYI(1, "Getting mode bits from ACL");
693
		cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path, pfid);
694
	}
S
Steve French 已提交
695
#endif
696

697 698 699
	/* fill in remaining high mode bits e.g. SUID, VTX */
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
		cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
700

701 702 703 704 705 706 707
	/* check for Minshall+French symlinks */
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
		tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
		if (tmprc)
			cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
	}

708 709 710 711 712 713 714
	if (!*pinode) {
		*pinode = cifs_iget(sb, &fattr);
		if (!*pinode)
			rc = -ENOMEM;
	} else {
		cifs_fattr_to_inode(*pinode, &fattr);
	}
715

716
cgii_exit:
L
Linus Torvalds 已提交
717
	kfree(buf);
718
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
719 720 721
	return rc;
}

722 723 724 725
static const struct inode_operations cifs_ipc_inode_ops = {
	.lookup = cifs_lookup,
};

726
char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
727 728 729 730
{
	int pplen = cifs_sb->prepathlen;
	int dfsplen;
	char *full_path = NULL;
731
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
732 733 734 735 736 737 738 739 740

	/* if no prefix path, simply set path to the root of share to "" */
	if (pplen == 0) {
		full_path = kmalloc(1, GFP_KERNEL);
		if (full_path)
			full_path[0] = 0;
		return full_path;
	}

741 742
	if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
		dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
743 744 745 746 747 748 749 750
	else
		dfsplen = 0;

	full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
	if (full_path == NULL)
		return full_path;

	if (dfsplen) {
751
		strncpy(full_path, tcon->treeName, dfsplen);
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
		/* switch slash direction in prepath depending on whether
		 * windows or posix style path names
		 */
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
			int i;
			for (i = 0; i < dfsplen; i++) {
				if (full_path[i] == '\\')
					full_path[i] = '/';
			}
		}
	}
	strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
	full_path[dfsplen + pplen] = 0; /* add trailing null */
	return full_path;
}

768 769 770 771 772
static int
cifs_find_inode(struct inode *inode, void *opaque)
{
	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;

773
	/* don't match inode with different uniqueid */
774 775 776
	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
		return 0;

777 778 779 780
	/* don't match inode of different type */
	if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
		return 0;

781 782
	/* if it's not a directory or has no dentries, then flag it */
	if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
783 784
		fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;

785 786 787 788 789 790 791 792 793 794 795 796
	return 1;
}

static int
cifs_init_inode(struct inode *inode, void *opaque)
{
	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;

	CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
	return 0;
}

797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
/*
 * walk dentry list for an inode and report whether it has aliases that
 * are hashed. We use this to determine if a directory inode can actually
 * be used.
 */
static bool
inode_has_hashed_dentries(struct inode *inode)
{
	struct dentry *dentry;

	spin_lock(&dcache_lock);
	list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
		if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
			spin_unlock(&dcache_lock);
			return true;
		}
	}
	spin_unlock(&dcache_lock);
	return false;
}

818 819 820 821 822 823 824
/* Given fattrs, get a corresponding inode */
struct inode *
cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
{
	unsigned long hash;
	struct inode *inode;

825
retry_iget5_locked:
826
	cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
827 828 829 830 831 832

	/* hash down to 32-bits on 32-bit arch */
	hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);

	inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
	if (inode) {
833
		/* was there a potentially problematic inode collision? */
834 835
		if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
			fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
836 837 838 839 840 841 842

			if (inode_has_hashed_dentries(inode)) {
				cifs_autodisable_serverino(CIFS_SB(sb));
				iput(inode);
				fattr->cf_uniqueid = iunique(sb, ROOT_I);
				goto retry_iget5_locked;
			}
843 844
		}

845 846 847 848 849
		cifs_fattr_to_inode(inode, fattr);
		if (sb->s_flags & MS_NOATIME)
			inode->i_flags |= S_NOATIME | S_NOCMTIME;
		if (inode->i_state & I_NEW) {
			inode->i_ino = hash;
850 851
			if (S_ISREG(inode->i_mode))
				inode->i_data.backing_dev_info = sb->s_bdi;
S
Steve French 已提交
852
#ifdef CONFIG_CIFS_FSCACHE
853 854
			/* initialize per-inode cache cookie pointer */
			CIFS_I(inode)->fscache = NULL;
S
Steve French 已提交
855
#endif
856 857 858 859 860 861 862
			unlock_new_inode(inode);
		}
	}

	return inode;
}

L
Linus Torvalds 已提交
863
/* gets root inode */
864
struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
L
Linus Torvalds 已提交
865
{
866
	int xid;
867
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
868
	struct inode *inode = NULL;
869
	long rc;
870
	char *full_path;
871
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
872

873
	full_path = cifs_build_path_to_root(cifs_sb);
874 875
	if (full_path == NULL)
		return ERR_PTR(-ENOMEM);
876

877
	xid = GetXid();
878
	if (tcon->unix_ext)
879
		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
880 881
	else
		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
882
						xid, NULL);
883 884

	if (!inode)
885
		return ERR_PTR(rc);
886

S
Steve French 已提交
887
#ifdef CONFIG_CIFS_FSCACHE
888
	/* populate tcon->resource_id */
889
	tcon->resource_id = CIFS_I(inode)->uniqueid;
S
Steve French 已提交
890
#endif
891

892
	if (rc && tcon->ipc) {
893
		cFYI(1, "ipc connection - fake read inode");
894 895 896 897 898 899
		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;
900
	} else if (rc) {
901
		kfree(full_path);
902 903 904
		_FreeXid(xid);
		iget_failed(inode);
		return ERR_PTR(rc);
905 906
	}

907

908
	kfree(full_path);
909 910 911
	/* can not call macro FreeXid here since in a void func
	 * TODO: This is no longer true
	 */
L
Linus Torvalds 已提交
912
	_FreeXid(xid);
913
	return inode;
L
Linus Torvalds 已提交
914 915
}

916 917 918 919 920 921 922 923 924 925 926 927
static int
cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
		    char *full_path, __u32 dosattr)
{
	int rc;
	int oplock = 0;
	__u16 netfid;
	__u32 netpid;
	bool set_time = false;
	struct cifsFileInfo *open_file;
	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
928
	struct tcon_link *tlink = NULL;
929
	struct cifsTconInfo *pTcon;
930 931
	FILE_BASIC_INFO	info_buf;

S
Steve French 已提交
932 933 934
	if (attrs == NULL)
		return -EINVAL;

935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
	if (attrs->ia_valid & ATTR_ATIME) {
		set_time = true;
		info_buf.LastAccessTime =
			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
	} else
		info_buf.LastAccessTime = 0;

	if (attrs->ia_valid & ATTR_MTIME) {
		set_time = true;
		info_buf.LastWriteTime =
		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
	} else
		info_buf.LastWriteTime = 0;

	/*
	 * Samba throws this field away, but windows may actually use it.
	 * Do not set ctime unless other time stamps are changed explicitly
	 * (i.e. by utimes()) since we would then have a mix of client and
	 * server times.
	 */
	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
956
		cFYI(1, "CIFS - CTIME changed");
957 958 959 960 961 962 963 964 965 966 967
		info_buf.ChangeTime =
		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
	} else
		info_buf.ChangeTime = 0;

	info_buf.CreationTime = 0;	/* don't change */
	info_buf.Attributes = cpu_to_le32(dosattr);

	/*
	 * If the file is already open for write, just use that fileid
	 */
968
	open_file = find_writable_file(cifsInode, true);
969 970 971
	if (open_file) {
		netfid = open_file->netfid;
		netpid = open_file->pid;
972
		pTcon = tlink_tcon(open_file->tlink);
973 974 975
		goto set_via_filehandle;
	}

976 977 978 979 980 981 982
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
		rc = PTR_ERR(tlink);
		tlink = NULL;
		goto out;
	}
	pTcon = tlink_tcon(tlink);
983

984 985 986 987 988 989 990 991 992
	/*
	 * NT4 apparently returns success on this call, but it doesn't
	 * really work.
	 */
	if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
		rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
				     &info_buf, cifs_sb->local_nls,
				     cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
993 994 995 996
		if (rc == 0) {
			cifsInode->cifsAttrs = dosattr;
			goto out;
		} else if (rc != -EOPNOTSUPP && rc != -EINVAL)
997 998 999
			goto out;
	}

1000 1001
	cFYI(1, "calling SetFileInfo since SetPathInfo for "
		 "times not supported by this server");
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
			 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
			 CREATE_NOT_DIR, &netfid, &oplock,
			 NULL, cifs_sb->local_nls,
			 cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);

	if (rc != 0) {
		if (rc == -EIO)
			rc = -EINVAL;
		goto out;
	}

	netpid = current->tgid;

set_via_filehandle:
	rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1019 1020 1021
	if (!rc)
		cifsInode->cifsAttrs = dosattr;

1022 1023 1024
	if (open_file == NULL)
		CIFSSMBClose(xid, pTcon, netfid);
	else
1025
		cifsFileInfo_put(open_file);
1026
out:
1027 1028
	if (tlink != NULL)
		cifs_put_tlink(tlink);
1029 1030 1031
	return rc;
}

1032 1033 1034 1035 1036 1037
/*
 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
 * and rename it to a random name that hopefully won't conflict with
 * anything else.
 */
static int
1038
cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1039 1040 1041 1042
{
	int oplock = 0;
	int rc;
	__u16 netfid;
1043
	struct inode *inode = dentry->d_inode;
1044 1045
	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1046 1047
	struct tcon_link *tlink;
	struct cifsTconInfo *tcon;
1048 1049
	__u32 dosattr, origattr;
	FILE_BASIC_INFO *info_buf = NULL;
1050

1051 1052 1053 1054 1055
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);

1056
	rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1057
			 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1058 1059 1060 1061 1062
			 &netfid, &oplock, NULL, cifs_sb->local_nls,
			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
	if (rc != 0)
		goto out;

1063 1064 1065 1066 1067
	origattr = cifsInode->cifsAttrs;
	if (origattr == 0)
		origattr |= ATTR_NORMAL;

	dosattr = origattr & ~ATTR_READONLY;
1068 1069 1070 1071
	if (dosattr == 0)
		dosattr |= ATTR_NORMAL;
	dosattr |= ATTR_HIDDEN;

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
	if (dosattr != origattr) {
		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
		if (info_buf == NULL) {
			rc = -ENOMEM;
			goto out_close;
		}
		info_buf->Attributes = cpu_to_le32(dosattr);
		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
					current->tgid);
		/* although we would like to mark the file hidden
 		   if that fails we will still try to rename it */
S
Steve French 已提交
1084
		if (rc != 0)
1085 1086 1087
			cifsInode->cifsAttrs = dosattr;
		else
			dosattr = origattr; /* since not able to change them */
1088 1089
	}

1090 1091
	/* rename the file */
	rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1092 1093
				   cifs_sb->mnt_cifs_flags &
					    CIFS_MOUNT_MAP_SPECIAL_CHR);
1094 1095 1096 1097
	if (rc != 0) {
		rc = -ETXTBSY;
		goto undo_setattr;
	}
1098

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	/* try to set DELETE_ON_CLOSE */
	if (!cifsInode->delete_pending) {
		rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
					       current->tgid);
		/*
		 * some samba versions return -ENOENT when we try to set the
		 * file disposition here. Likely a samba bug, but work around
		 * it for now. This means that some cifsXXX files may hang
		 * around after they shouldn't.
		 *
		 * BB: remove this hack after more servers have the fix
		 */
		if (rc == -ENOENT)
			rc = 0;
		else if (rc != 0) {
			rc = -ETXTBSY;
			goto undo_rename;
		}
		cifsInode->delete_pending = true;
	}
1119

1120 1121 1122
out_close:
	CIFSSMBClose(xid, tcon, netfid);
out:
1123
	kfree(info_buf);
1124
	cifs_put_tlink(tlink);
1125
	return rc;
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144

	/*
	 * reset everything back to the original state. Don't bother
	 * dealing with errors here since we can't do anything about
	 * them anyway.
	 */
undo_rename:
	CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					    CIFS_MOUNT_MAP_SPECIAL_CHR);
undo_setattr:
	if (dosattr != origattr) {
		info_buf->Attributes = cpu_to_le32(origattr);
		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
					current->tgid))
			cifsInode->cifsAttrs = origattr;
	}

	goto out_close;
1145 1146
}

1147 1148 1149 1150

/*
 * If dentry->d_inode is null (usually meaning the cached dentry
 * is a negative dentry) then we would attempt a standard SMB delete, but
1151 1152
 * if that fails we can not attempt the fall back mechanisms on EACCESS
 * but will return the EACCESS to the caller. Note that the VFS does not call
1153 1154
 * unlink on negative dentries currently.
 */
1155
int cifs_unlink(struct inode *dir, struct dentry *dentry)
L
Linus Torvalds 已提交
1156 1157 1158 1159
{
	int rc = 0;
	int xid;
	char *full_path = NULL;
1160
	struct inode *inode = dentry->d_inode;
1161
	struct cifsInodeInfo *cifs_inode;
1162 1163
	struct super_block *sb = dir->i_sb;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1164 1165
	struct tcon_link *tlink;
	struct cifsTconInfo *tcon;
1166 1167
	struct iattr *attrs = NULL;
	__u32 dosattr = 0, origattr = 0;
L
Linus Torvalds 已提交
1168

1169
	cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
L
Linus Torvalds 已提交
1170

1171 1172 1173 1174 1175
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);

L
Linus Torvalds 已提交
1176 1177
	xid = GetXid();

1178 1179 1180
	/* Unlink can be called from rename so we can not take the
	 * sb->s_vfs_rename_mutex here */
	full_path = build_path_from_dentry(dentry);
L
Linus Torvalds 已提交
1181
	if (full_path == NULL) {
1182
		rc = -ENOMEM;
1183
		goto unlink_out;
L
Linus Torvalds 已提交
1184
	}
1185

1186
	if ((tcon->ses->capabilities & CAP_UNIX) &&
1187
		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
1188 1189
			le64_to_cpu(tcon->fsUnixInfo.Capability))) {
		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1190
			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1191
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1192
		cFYI(1, "posix del rc %d", rc);
1193 1194 1195
		if ((rc == 0) || (rc == -ENOENT))
			goto psx_del_no_retry;
	}
L
Linus Torvalds 已提交
1196

1197
retry_std_delete:
1198
	rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1199
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1200

1201
psx_del_no_retry:
L
Linus Torvalds 已提交
1202
	if (!rc) {
1203 1204
		if (inode)
			drop_nlink(inode);
L
Linus Torvalds 已提交
1205
	} else if (rc == -ENOENT) {
1206
		d_drop(dentry);
L
Linus Torvalds 已提交
1207
	} else if (rc == -ETXTBSY) {
1208
		rc = cifs_rename_pending_delete(full_path, dentry, xid);
1209 1210
		if (rc == 0)
			drop_nlink(inode);
1211
	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1212 1213 1214 1215
		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
		if (attrs == NULL) {
			rc = -ENOMEM;
			goto out_reval;
L
Linus Torvalds 已提交
1216
		}
1217 1218

		/* try to reset dos attributes */
1219 1220
		cifs_inode = CIFS_I(inode);
		origattr = cifs_inode->cifsAttrs;
1221 1222 1223
		if (origattr == 0)
			origattr |= ATTR_NORMAL;
		dosattr = origattr & ~ATTR_READONLY;
1224 1225 1226 1227 1228 1229 1230
		if (dosattr == 0)
			dosattr |= ATTR_NORMAL;
		dosattr |= ATTR_HIDDEN;

		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
		if (rc != 0)
			goto out_reval;
1231 1232

		goto retry_std_delete;
L
Linus Torvalds 已提交
1233
	}
1234 1235 1236 1237 1238

	/* undo the setattr if we errored out and it's needed */
	if (rc != 0 && dosattr != 0)
		cifs_set_file_info(inode, attrs, xid, full_path, origattr);

1239
out_reval:
1240
	if (inode) {
1241 1242
		cifs_inode = CIFS_I(inode);
		cifs_inode->time = 0;	/* will force revalidate to get info
1243 1244
					   when needed */
		inode->i_ctime = current_fs_time(sb);
1245
	}
1246
	dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1247
	cifs_inode = CIFS_I(dir);
1248
	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */
1249
unlink_out:
L
Linus Torvalds 已提交
1250
	kfree(full_path);
1251
	kfree(attrs);
L
Linus Torvalds 已提交
1252
	FreeXid(xid);
1253
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
1254 1255 1256 1257 1258
	return rc;
}

int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
{
1259
	int rc = 0, tmprc;
L
Linus Torvalds 已提交
1260 1261
	int xid;
	struct cifs_sb_info *cifs_sb;
1262
	struct tcon_link *tlink;
L
Linus Torvalds 已提交
1263 1264 1265
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	struct inode *newinode = NULL;
1266
	struct cifs_fattr fattr;
L
Linus Torvalds 已提交
1267

1268
	cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
L
Linus Torvalds 已提交
1269 1270

	cifs_sb = CIFS_SB(inode->i_sb);
1271 1272 1273 1274 1275 1276
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

	xid = GetXid();
L
Linus Torvalds 已提交
1277

1278
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
1279
	if (full_path == NULL) {
1280
		rc = -ENOMEM;
1281
		goto mkdir_out;
L
Linus Torvalds 已提交
1282
	}
1283

S
Steve French 已提交
1284 1285
	if ((pTcon->ses->capabilities & CAP_UNIX) &&
		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
1286 1287
			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
		u32 oplock = 0;
1288
		FILE_UNIX_BASIC_INFO *pInfo =
1289
			kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
S
Steve French 已提交
1290
		if (pInfo == NULL) {
1291 1292 1293
			rc = -ENOMEM;
			goto mkdir_out;
		}
1294

A
Al Viro 已提交
1295
		mode &= ~current_umask();
1296 1297
		rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
				mode, NULL /* netfid */, pInfo, &oplock,
S
Steve French 已提交
1298 1299
				full_path, cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
1300
					CIFS_MOUNT_MAP_SPECIAL_CHR);
1301 1302 1303 1304
		if (rc == -EOPNOTSUPP) {
			kfree(pInfo);
			goto mkdir_retry_old;
		} else if (rc) {
1305
			cFYI(1, "posix mkdir returned 0x%x", rc);
1306 1307
			d_drop(direntry);
		} else {
1308 1309
			if (pInfo->Type == cpu_to_le32(-1)) {
				/* no return info, go query for it */
1310
				kfree(pInfo);
S
Steve French 已提交
1311
				goto mkdir_get_info;
1312
			}
S
Steve French 已提交
1313 1314
/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
	to set uid/gid */
1315 1316 1317 1318 1319
			inc_nlink(inode);
			if (pTcon->nocase)
				direntry->d_op = &cifs_ci_dentry_ops;
			else
				direntry->d_op = &cifs_dentry_ops;
1320

1321
			cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1322
			cifs_fill_uniqueid(inode->i_sb, &fattr);
1323 1324
			newinode = cifs_iget(inode->i_sb, &fattr);
			if (!newinode) {
1325
				kfree(pInfo);
1326
				goto mkdir_get_info;
1327
			}
1328

1329
			d_instantiate(direntry, newinode);
1330 1331

#ifdef CONFIG_CIFS_DEBUG2
1332 1333
			cFYI(1, "instantiated dentry %p %s to inode %p",
				direntry, direntry->d_name.name, newinode);
1334

S
Steve French 已提交
1335
			if (newinode->i_nlink != 2)
1336 1337
				cFYI(1, "unexpected number of links %d",
					newinode->i_nlink);
1338
#endif
1339 1340 1341
		}
		kfree(pInfo);
		goto mkdir_out;
S
Steve French 已提交
1342
	}
1343
mkdir_retry_old:
L
Linus Torvalds 已提交
1344
	/* BB add setting the equivalent of mode via CreateX w/ACLs */
1345 1346
	rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
L
Linus Torvalds 已提交
1347
	if (rc) {
1348
		cFYI(1, "cifs_mkdir returned 0x%x", rc);
L
Linus Torvalds 已提交
1349 1350
		d_drop(direntry);
	} else {
S
Steve French 已提交
1351
mkdir_get_info:
1352
		inc_nlink(inode);
1353
		if (pTcon->unix_ext)
L
Linus Torvalds 已提交
1354
			rc = cifs_get_inode_info_unix(&newinode, full_path,
S
Steve French 已提交
1355
						      inode->i_sb, xid);
L
Linus Torvalds 已提交
1356 1357
		else
			rc = cifs_get_inode_info(&newinode, full_path, NULL,
1358
						 inode->i_sb, xid, NULL);
L
Linus Torvalds 已提交
1359

1360 1361 1362 1363
		if (pTcon->nocase)
			direntry->d_op = &cifs_ci_dentry_ops;
		else
			direntry->d_op = &cifs_dentry_ops;
L
Linus Torvalds 已提交
1364
		d_instantiate(direntry, newinode);
1365
		 /* setting nlink not necessary except in cases where we
S
Steve French 已提交
1366
		  * failed to get it from the server or was set bogus */
1367
		if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
S
Steve French 已提交
1368
				direntry->d_inode->i_nlink = 2;
1369

A
Al Viro 已提交
1370
		mode &= ~current_umask();
1371 1372 1373 1374
		/* must turn on setgid bit if parent dir has it */
		if (inode->i_mode & S_ISGID)
			mode |= S_ISGID;

1375
		if (pTcon->unix_ext) {
1376 1377 1378 1379 1380 1381 1382
			struct cifs_unix_set_info_args args = {
				.mode	= mode,
				.ctime	= NO_CHANGE_64,
				.atime	= NO_CHANGE_64,
				.mtime	= NO_CHANGE_64,
				.device	= 0,
			};
1383
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1384
				args.uid = (__u64)current_fsuid();
1385 1386 1387
				if (inode->i_mode & S_ISGID)
					args.gid = (__u64)inode->i_gid;
				else
1388
					args.gid = (__u64)current_fsgid();
L
Linus Torvalds 已提交
1389
			} else {
1390 1391
				args.uid = NO_CHANGE_64;
				args.gid = NO_CHANGE_64;
L
Linus Torvalds 已提交
1392
			}
1393 1394 1395 1396
			CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
					       cifs_sb->local_nls,
					       cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
S
Steve French 已提交
1397
		} else {
1398 1399 1400
			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
			    (mode & S_IWUGO) == 0) {
				FILE_BASIC_INFO pInfo;
1401 1402 1403
				struct cifsInodeInfo *cifsInode;
				u32 dosattrs;

1404
				memset(&pInfo, 0, sizeof(pInfo));
1405 1406 1407 1408 1409 1410
				cifsInode = CIFS_I(newinode);
				dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
				pInfo.Attributes = cpu_to_le32(dosattrs);
				tmprc = CIFSSMBSetPathInfo(xid, pTcon,
						full_path, &pInfo,
						cifs_sb->local_nls,
1411 1412
						cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
1413 1414
				if (tmprc == 0)
					cifsInode->cifsAttrs = dosattrs;
1415
			}
S
Steve French 已提交
1416
			if (direntry->d_inode) {
1417 1418 1419 1420
				if (cifs_sb->mnt_cifs_flags &
				     CIFS_MOUNT_DYNPERM)
					direntry->d_inode->i_mode =
						(mode | S_IFDIR);
S
Steve French 已提交
1421

S
Steve French 已提交
1422
				if (cifs_sb->mnt_cifs_flags &
1423
				     CIFS_MOUNT_SET_UID) {
S
Steve French 已提交
1424
					direntry->d_inode->i_uid =
1425
						current_fsuid();
1426 1427 1428 1429 1430
					if (inode->i_mode & S_ISGID)
						direntry->d_inode->i_gid =
							inode->i_gid;
					else
						direntry->d_inode->i_gid =
1431
							current_fsgid();
1432 1433
				}
			}
1434
		}
L
Linus Torvalds 已提交
1435
	}
S
Steve French 已提交
1436
mkdir_out:
L
Linus Torvalds 已提交
1437 1438
	kfree(full_path);
	FreeXid(xid);
1439
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
1440 1441 1442 1443 1444 1445 1446 1447
	return rc;
}

int cifs_rmdir(struct inode *inode, struct dentry *direntry)
{
	int rc = 0;
	int xid;
	struct cifs_sb_info *cifs_sb;
1448
	struct tcon_link *tlink;
L
Linus Torvalds 已提交
1449 1450 1451 1452
	struct cifsTconInfo *pTcon;
	char *full_path = NULL;
	struct cifsInodeInfo *cifsInode;

1453
	cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
L
Linus Torvalds 已提交
1454 1455 1456

	xid = GetXid();

1457
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
1458
	if (full_path == NULL) {
1459
		rc = -ENOMEM;
1460
		goto rmdir_exit;
L
Linus Torvalds 已提交
1461 1462
	}

1463 1464 1465 1466 1467 1468 1469 1470
	cifs_sb = CIFS_SB(inode->i_sb);
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
		rc = PTR_ERR(tlink);
		goto rmdir_exit;
	}
	pTcon = tlink_tcon(tlink);

1471 1472
	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1473
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
1474 1475

	if (!rc) {
1476
		drop_nlink(inode);
1477
		spin_lock(&direntry->d_inode->i_lock);
S
Steve French 已提交
1478
		i_size_write(direntry->d_inode, 0);
1479
		clear_nlink(direntry->d_inode);
1480
		spin_unlock(&direntry->d_inode->i_lock);
L
Linus Torvalds 已提交
1481 1482 1483 1484 1485
	}

	cifsInode = CIFS_I(direntry->d_inode);
	cifsInode->time = 0;	/* force revalidate to go get info when
				   needed */
1486 1487 1488 1489 1490

	cifsInode = CIFS_I(inode);
	cifsInode->time = 0;	/* force revalidate to get parent dir info
				   since cached search results now invalid */

L
Linus Torvalds 已提交
1491 1492 1493
	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
		current_fs_time(inode->i_sb);

1494
rmdir_exit:
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

1500 1501 1502 1503 1504
static int
cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
		struct dentry *to_dentry, const char *toPath)
{
	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1505 1506
	struct tcon_link *tlink;
	struct cifsTconInfo *pTcon;
1507 1508 1509
	__u16 srcfid;
	int oplock, rc;

1510 1511 1512 1513 1514
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	/* try path-based rename first */
	rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
			   cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);

	/*
	 * don't bother with rename by filehandle unless file is busy and
	 * source Note that cross directory moves do not work with
	 * rename by filehandle to various Windows servers.
	 */
	if (rc == 0 || rc != -ETXTBSY)
1526
		goto do_rename_exit;
1527

1528 1529
	/* open-file renames don't work across directories */
	if (to_dentry->d_parent != from_dentry->d_parent)
1530
		goto do_rename_exit;
1531

1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
	/* open the file to be renamed -- we need DELETE perms */
	rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
			 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
			 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
				CIFS_MOUNT_MAP_SPECIAL_CHR);

	if (rc == 0) {
		rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
				(const char *) to_dentry->d_name.name,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);

		CIFSSMBClose(xid, pTcon, srcfid);
	}
1546 1547
do_rename_exit:
	cifs_put_tlink(tlink);
1548 1549 1550
	return rc;
}

1551 1552
int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
	struct inode *target_dir, struct dentry *target_dentry)
L
Linus Torvalds 已提交
1553
{
1554 1555
	char *fromName = NULL;
	char *toName = NULL;
1556
	struct cifs_sb_info *cifs_sb;
1557
	struct tcon_link *tlink;
1558
	struct cifsTconInfo *tcon;
1559 1560
	FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
	FILE_UNIX_BASIC_INFO *info_buf_target;
1561
	int xid, rc, tmprc;
L
Linus Torvalds 已提交
1562

1563
	cifs_sb = CIFS_SB(source_dir->i_sb);
1564 1565 1566 1567
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	tcon = tlink_tcon(tlink);
L
Linus Torvalds 已提交
1568

1569 1570 1571 1572 1573 1574
	xid = GetXid();

	/*
	 * we already have the rename sem so we do not need to
	 * grab it again here to protect the path integrity
	 */
1575
	fromName = build_path_from_dentry(source_dentry);
1576 1577 1578 1579 1580
	if (fromName == NULL) {
		rc = -ENOMEM;
		goto cifs_rename_exit;
	}

1581
	toName = build_path_from_dentry(target_dentry);
1582
	if (toName == NULL) {
L
Linus Torvalds 已提交
1583 1584 1585 1586
		rc = -ENOMEM;
		goto cifs_rename_exit;
	}

1587 1588
	rc = cifs_do_rename(xid, source_dentry, fromName,
			    target_dentry, toName);
1589

1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
	if (rc == -EEXIST && tcon->unix_ext) {
		/*
		 * Are src and dst hardlinks of same inode? We can
		 * only tell with unix extensions enabled
		 */
		info_buf_source =
			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
					GFP_KERNEL);
		if (info_buf_source == NULL) {
			rc = -ENOMEM;
			goto cifs_rename_exit;
		}

		info_buf_target = info_buf_source + 1;
1604
		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1605
					info_buf_source,
1606 1607
					cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
1608
					CIFS_MOUNT_MAP_SPECIAL_CHR);
1609
		if (tmprc != 0)
1610
			goto unlink_target;
1611

1612 1613 1614 1615
		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
					info_buf_target,
					cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
1616 1617
					CIFS_MOUNT_MAP_SPECIAL_CHR);

1618
		if (tmprc == 0 && (info_buf_source->UniqueId ==
1619
				   info_buf_target->UniqueId)) {
1620
			/* same file, POSIX says that this is a noop */
1621
			rc = 0;
1622
			goto cifs_rename_exit;
1623
		}
1624
	} /* else ... BB we could add the same check for Windows by
1625
		     checking the UniqueId via FILE_INTERNAL_INFO */
1626

1627
unlink_target:
1628 1629
	/* Try unlinking the target dentry if it's not negative */
	if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1630
		tmprc = cifs_unlink(target_dir, target_dentry);
1631 1632 1633 1634 1635
		if (tmprc)
			goto cifs_rename_exit;

		rc = cifs_do_rename(xid, source_dentry, fromName,
				    target_dentry, toName);
L
Linus Torvalds 已提交
1636 1637 1638
	}

cifs_rename_exit:
1639
	kfree(info_buf_source);
L
Linus Torvalds 已提交
1640 1641 1642
	kfree(fromName);
	kfree(toName);
	FreeXid(xid);
1643
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
1644 1645 1646
	return rc;
}

1647 1648
static bool
cifs_inode_needs_reval(struct inode *inode)
L
Linus Torvalds 已提交
1649
{
1650
	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
L
Linus Torvalds 已提交
1651

1652 1653
	if (cifs_i->clientCanCacheRead)
		return false;
L
Linus Torvalds 已提交
1654

1655 1656
	if (!lookupCacheEnabled)
		return true;
L
Linus Torvalds 已提交
1657

1658 1659
	if (cifs_i->time == 0)
		return true;
L
Linus Torvalds 已提交
1660

1661 1662 1663 1664
	/* FIXME: the actimeo should be tunable */
	if (time_after_eq(jiffies, cifs_i->time + HZ))
		return true;

1665 1666 1667 1668 1669
	/* hardlinked files w/ noserverino get "special" treatment */
	if (!(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
	    S_ISREG(inode->i_mode) && inode->i_nlink != 1)
		return true;

1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
	return false;
}

/* check invalid_mapping flag and zap the cache if it's set */
static void
cifs_invalidate_mapping(struct inode *inode)
{
	int rc;
	struct cifsInodeInfo *cifs_i = CIFS_I(inode);

	cifs_i->invalid_mapping = false;

	/* write back any cached data */
	if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
		rc = filemap_write_and_wait(inode->i_mapping);
1685
		mapping_set_error(inode->i_mapping, rc);
1686 1687
	}
	invalidate_remote_inode(inode);
1688
	cifs_fscache_reset_inode_cookie(inode);
1689 1690
}

J
Jeff Layton 已提交
1691 1692 1693 1694
int cifs_revalidate_file(struct file *filp)
{
	int rc = 0;
	struct inode *inode = filp->f_path.dentry->d_inode;
1695
	struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
J
Jeff Layton 已提交
1696 1697 1698 1699

	if (!cifs_inode_needs_reval(inode))
		goto check_inval;

1700
	if (tlink_tcon(cfile->tlink)->unix_ext)
J
Jeff Layton 已提交
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
		rc = cifs_get_file_info_unix(filp);
	else
		rc = cifs_get_file_info(filp);

check_inval:
	if (CIFS_I(inode)->invalid_mapping)
		cifs_invalidate_mapping(inode);

	return rc;
}

1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
/* revalidate a dentry's inode attributes */
int cifs_revalidate_dentry(struct dentry *dentry)
{
	int xid;
	int rc = 0;
	char *full_path = NULL;
	struct inode *inode = dentry->d_inode;
	struct super_block *sb = dentry->d_sb;

	if (inode == NULL)
		return -ENOENT;
L
Linus Torvalds 已提交
1723 1724 1725

	xid = GetXid();

1726 1727
	if (!cifs_inode_needs_reval(inode))
		goto check_inval;
L
Linus Torvalds 已提交
1728 1729 1730

	/* can not safely grab the rename sem here if rename calls revalidate
	   since that would deadlock */
1731
	full_path = build_path_from_dentry(dentry);
L
Linus Torvalds 已提交
1732
	if (full_path == NULL) {
1733
		rc = -ENOMEM;
1734
		goto check_inval;
L
Linus Torvalds 已提交
1735 1736
	}

1737
	cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1738
		 "jiffies %ld", full_path, inode, inode->i_count.counter,
1739
		 dentry, dentry->d_time, jiffies);
L
Linus Torvalds 已提交
1740

1741
	if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1742 1743 1744 1745
		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
	else
		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
					 xid, NULL);
L
Linus Torvalds 已提交
1746

1747 1748 1749
check_inval:
	if (CIFS_I(inode)->invalid_mapping)
		cifs_invalidate_mapping(inode);
1750

L
Linus Torvalds 已提交
1751 1752 1753 1754 1755 1756
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1757
		 struct kstat *stat)
L
Linus Torvalds 已提交
1758
{
1759 1760
	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
	struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
1761
	int err = cifs_revalidate_dentry(dentry);
1762

S
Steve French 已提交
1763
	if (!err) {
L
Linus Torvalds 已提交
1764
		generic_fillattr(dentry->d_inode, stat);
S
Steve French 已提交
1765
		stat->blksize = CIFS_MAX_MSGSIZE;
1766
		stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1767 1768 1769 1770 1771 1772

		/*
		 * If on a multiuser mount without unix extensions, and the
		 * admin hasn't overridden them, set the ownership to the
		 * fsuid/fsgid of the current process.
		 */
1773 1774
		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
		    !tcon->unix_ext) {
1775
			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1776
				stat->uid = current_fsuid();
1777
			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1778 1779
				stat->gid = current_fsgid();
		}
S
Steve French 已提交
1780
	}
L
Linus Torvalds 已提交
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
	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;

1795
	zero_user_segment(page, offset, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800
	unlock_page(page);
	page_cache_release(page);
	return rc;
}

C
Christoph Hellwig 已提交
1801
static void cifs_setsize(struct inode *inode, loff_t offset)
1802
{
N
npiggin@suse.de 已提交
1803
	loff_t oldsize;
1804

1805
	spin_lock(&inode->i_lock);
N
npiggin@suse.de 已提交
1806
	oldsize = inode->i_size;
1807
	i_size_write(inode, offset);
1808
	spin_unlock(&inode->i_lock);
C
Christoph Hellwig 已提交
1809

N
npiggin@suse.de 已提交
1810
	truncate_pagecache(inode, oldsize, offset);
1811 1812
}

1813 1814 1815 1816 1817 1818 1819 1820
static int
cifs_set_file_size(struct inode *inode, struct iattr *attrs,
		   int xid, char *full_path)
{
	int rc;
	struct cifsFileInfo *open_file;
	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1821
	struct tcon_link *tlink = NULL;
1822
	struct cifsTconInfo *pTcon = NULL;
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832

	/*
	 * 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
	 */
1833
	open_file = find_writable_file(cifsInode, true);
1834 1835 1836
	if (open_file) {
		__u16 nfid = open_file->netfid;
		__u32 npid = open_file->pid;
1837
		pTcon = tlink_tcon(open_file->tlink);
1838 1839
		rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
					npid, false);
1840
		cifsFileInfo_put(open_file);
1841
		cFYI(1, "SetFSize for attrs rc = %d", rc);
1842 1843 1844 1845
		if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
			unsigned int bytes_written;
			rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
					  &bytes_written, NULL, NULL, 1);
1846
			cFYI(1, "Wrt seteof rc %d", rc);
1847 1848 1849 1850 1851
		}
	} else
		rc = -EINVAL;

	if (rc != 0) {
1852 1853 1854 1855 1856 1857
		if (pTcon == NULL) {
			tlink = cifs_sb_tlink(cifs_sb);
			if (IS_ERR(tlink))
				return PTR_ERR(tlink);
			pTcon = tlink_tcon(tlink);
		}
1858

1859 1860 1861 1862 1863 1864 1865 1866
		/* 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, attrs->ia_size,
				   false, cifs_sb->local_nls,
				   cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
1867
		cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
		if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
			__u16 netfid;
			int oplock = 0;

			rc = SMBLegacyOpen(xid, pTcon, full_path,
				FILE_OPEN, GENERIC_WRITE,
				CREATE_NOT_DIR, &netfid, &oplock, NULL,
				cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
			if (rc == 0) {
				unsigned int bytes_written;
				rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
						  attrs->ia_size,
						  &bytes_written, NULL,
						  NULL, 1);
1884
				cFYI(1, "wrt seteof rc %d", rc);
1885 1886 1887
				CIFSSMBClose(xid, pTcon, netfid);
			}
		}
1888 1889
		if (tlink)
			cifs_put_tlink(tlink);
1890 1891 1892
	}

	if (rc == 0) {
1893
		cifsInode->server_eof = attrs->ia_size;
C
Christoph Hellwig 已提交
1894
		cifs_setsize(inode, attrs->ia_size);
1895 1896 1897 1898 1899 1900
		cifs_truncate_page(inode->i_mapping, inode->i_size);
	}

	return rc;
}

1901 1902 1903 1904 1905 1906 1907 1908 1909
static int
cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
{
	int rc;
	int xid;
	char *full_path = NULL;
	struct inode *inode = direntry->d_inode;
	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1910
	struct tcon_link *tlink;
1911
	struct cifsTconInfo *pTcon;
1912
	struct cifs_unix_set_info_args *args = NULL;
1913
	struct cifsFileInfo *open_file;
1914

1915 1916
	cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
		 direntry->d_name.name, attrs->ia_valid);
1917 1918 1919

	xid = GetXid();

1920 1921 1922 1923 1924 1925
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
		attrs->ia_valid |= ATTR_FORCE;

	rc = inode_change_ok(inode, attrs);
	if (rc < 0)
		goto out;
1926 1927 1928 1929 1930 1931 1932

	full_path = build_path_from_dentry(direntry);
	if (full_path == NULL) {
		rc = -ENOMEM;
		goto out;
	}

J
Jeff Layton 已提交
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
	/*
	 * Attempt to flush data before changing attributes. We need to do
	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
	 * ownership or mode then we may also need to do this. Here, we take
	 * the safe way out and just do the flush on all setattr requests. If
	 * the 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?
	 */
	rc = filemap_write_and_wait(inode->i_mapping);
1945 1946
	mapping_set_error(inode->i_mapping, rc);
	rc = 0;
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995

	if (attrs->ia_valid & ATTR_SIZE) {
		rc = cifs_set_file_size(inode, attrs, xid, full_path);
		if (rc != 0)
			goto out;
	}

	/* 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;

	args = kmalloc(sizeof(*args), GFP_KERNEL);
	if (args == NULL) {
		rc = -ENOMEM;
		goto out;
	}

	/* set up the struct */
	if (attrs->ia_valid & ATTR_MODE)
		args->mode = attrs->ia_mode;
	else
		args->mode = NO_CHANGE_64;

	if (attrs->ia_valid & ATTR_UID)
		args->uid = attrs->ia_uid;
	else
		args->uid = NO_CHANGE_64;

	if (attrs->ia_valid & ATTR_GID)
		args->gid = attrs->ia_gid;
	else
		args->gid = NO_CHANGE_64;

	if (attrs->ia_valid & ATTR_ATIME)
		args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
	else
		args->atime = NO_CHANGE_64;

	if (attrs->ia_valid & ATTR_MTIME)
		args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
	else
		args->mtime = NO_CHANGE_64;

	if (attrs->ia_valid & ATTR_CTIME)
		args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
	else
		args->ctime = NO_CHANGE_64;

	args->device = 0;
1996
	open_file = find_writable_file(cifsInode, true);
1997 1998 1999
	if (open_file) {
		u16 nfid = open_file->netfid;
		u32 npid = open_file->pid;
2000
		pTcon = tlink_tcon(open_file->tlink);
2001
		rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2002
		cifsFileInfo_put(open_file);
2003
	} else {
2004 2005 2006 2007 2008 2009
		tlink = cifs_sb_tlink(cifs_sb);
		if (IS_ERR(tlink)) {
			rc = PTR_ERR(tlink);
			goto out;
		}
		pTcon = tlink_tcon(tlink);
2010
		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2011 2012 2013
				    cifs_sb->local_nls,
				    cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
2014
		cifs_put_tlink(tlink);
2015
	}
2016

C
Christoph Hellwig 已提交
2017 2018
	if (rc)
		goto out;
2019

C
Christoph Hellwig 已提交
2020
	if ((attrs->ia_valid & ATTR_SIZE) &&
C
Christoph Hellwig 已提交
2021 2022
	    attrs->ia_size != i_size_read(inode))
		truncate_setsize(inode, attrs->ia_size);
C
Christoph Hellwig 已提交
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034

	setattr_copy(inode, attrs);
	mark_inode_dirty(inode);

	/* force revalidate when any of these times are set since some
	   of the fs types (eg ext3, fat) do not have fine enough
	   time granularity to match protocol, and we do not have a
	   a way (yet) to query the server fs's time granularity (and
	   whether it rounds times down).
	*/
	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
		cifsInode->time = 0;
2035 2036 2037 2038 2039 2040 2041
out:
	kfree(args);
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

2042 2043
static int
cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
L
Linus Torvalds 已提交
2044 2045
{
	int xid;
2046 2047 2048
	struct inode *inode = direntry->d_inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
L
Linus Torvalds 已提交
2049 2050
	char *full_path = NULL;
	int rc = -EACCES;
2051
	__u32 dosattr = 0;
2052
	__u64 mode = NO_CHANGE_64;
2053

L
Linus Torvalds 已提交
2054 2055
	xid = GetXid();

2056 2057
	cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
		 direntry->d_name.name, attrs->ia_valid);
2058

2059 2060 2061 2062 2063 2064 2065
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
		attrs->ia_valid |= ATTR_FORCE;

	rc = inode_change_ok(inode, attrs);
	if (rc < 0) {
		FreeXid(xid);
		return rc;
2066
	}
2067

2068
	full_path = build_path_from_dentry(direntry);
L
Linus Torvalds 已提交
2069
	if (full_path == NULL) {
2070
		rc = -ENOMEM;
L
Linus Torvalds 已提交
2071
		FreeXid(xid);
2072
		return rc;
L
Linus Torvalds 已提交
2073 2074
	}

J
Jeff Layton 已提交
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
	/*
	 * Attempt to flush data before changing attributes. We need to do
	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
	 * ownership or mode then we may also need to do this. Here, we take
	 * the safe way out and just do the flush on all setattr requests. If
	 * the 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?
	 */
	rc = filemap_write_and_wait(inode->i_mapping);
2087 2088
	mapping_set_error(inode->i_mapping, rc);
	rc = 0;
2089

2090
	if (attrs->ia_valid & ATTR_SIZE) {
2091 2092
		rc = cifs_set_file_size(inode, attrs, xid, full_path);
		if (rc != 0)
2093
			goto cifs_setattr_exit;
L
Linus Torvalds 已提交
2094
	}
2095 2096 2097 2098 2099 2100 2101 2102

	/*
	 * Without unix extensions we can't send ownership changes to the
	 * server, so silently ignore them. This is consistent with how
	 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
	 * CIFSACL support + proper Windows to Unix idmapping, we may be
	 * able to support this in the future.
	 */
2103
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2104
		attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
L
Linus Torvalds 已提交
2105

2106 2107 2108 2109
	/* 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 已提交
2110
	if (attrs->ia_valid & ATTR_MODE) {
2111
		cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
L
Linus Torvalds 已提交
2112 2113 2114
		mode = attrs->ia_mode;
	}

2115
	if (attrs->ia_valid & ATTR_MODE) {
2116
		rc = 0;
2117 2118
#ifdef CONFIG_CIFS_EXPERIMENTAL
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
2119
			rc = mode_to_acl(inode, full_path, mode);
2120
		else
2121
#endif
2122 2123
		if (((mode & S_IWUGO) == 0) &&
		    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2124 2125 2126

			dosattr = cifsInode->cifsAttrs | ATTR_READONLY;

2127 2128 2129 2130 2131
			/* fix up mode if we're not using dynperm */
			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
				attrs->ia_mode = inode->i_mode & ~S_IWUGO;
		} else if ((mode & S_IWUGO) &&
			   (cifsInode->cifsAttrs & ATTR_READONLY)) {
2132 2133 2134 2135 2136

			dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
			/* Attributes of 0 are ignored */
			if (dosattr == 0)
				dosattr |= ATTR_NORMAL;
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150

			/* reset local inode permissions to normal */
			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
				attrs->ia_mode &= ~(S_IALLUGO);
				if (S_ISDIR(inode->i_mode))
					attrs->ia_mode |=
						cifs_sb->mnt_dir_mode;
				else
					attrs->ia_mode |=
						cifs_sb->mnt_file_mode;
			}
		} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
			/* ignore mode change - ATTR_READONLY hasn't changed */
			attrs->ia_valid &= ~ATTR_MODE;
L
Linus Torvalds 已提交
2151 2152 2153
		}
	}

2154 2155 2156 2157
	if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
	    ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
		/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
L
Linus Torvalds 已提交
2158

2159 2160 2161 2162 2163
		/* 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 已提交
2164
		if ((rc) && (attrs->ia_valid &
2165
				(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2166
			rc = 0;
L
Linus Torvalds 已提交
2167 2168 2169 2170
	}

	/* do not need local check to inode_check_ok since the server does
	   that */
C
Christoph Hellwig 已提交
2171 2172 2173 2174
	if (rc)
		goto cifs_setattr_exit;

	if ((attrs->ia_valid & ATTR_SIZE) &&
C
Christoph Hellwig 已提交
2175 2176
	    attrs->ia_size != i_size_read(inode))
		truncate_setsize(inode, attrs->ia_size);
C
Christoph Hellwig 已提交
2177 2178 2179 2180

	setattr_copy(inode, attrs);
	mark_inode_dirty(inode);

2181
cifs_setattr_exit:
L
Linus Torvalds 已提交
2182 2183 2184 2185 2186
	kfree(full_path);
	FreeXid(xid);
	return rc;
}

2187 2188 2189 2190 2191
int
cifs_setattr(struct dentry *direntry, struct iattr *attrs)
{
	struct inode *inode = direntry->d_inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2192
	struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
2193 2194 2195 2196 2197 2198 2199 2200 2201

	if (pTcon->unix_ext)
		return cifs_setattr_unix(direntry, attrs);

	return cifs_setattr_nounix(direntry, attrs);

	/* BB: add cifs_setattr_legacy for really old servers */
}

2202
#if 0
L
Linus Torvalds 已提交
2203 2204
void cifs_delete_inode(struct inode *inode)
{
2205
	cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
L
Linus Torvalds 已提交
2206 2207 2208
	/* may have to add back in if and when safe distributed caching of
	   directories added e.g. via FindNotify */
}
2209
#endif