inode.c 52 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *   fs/cifs/inode.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2007
Linus Torvalds's avatar
Linus Torvalds committed
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 32 33 34 35 36 37 38 39 40 41 42
 *   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"

int cifs_get_inode_info_unix(struct inode **pinode,
	const unsigned char *search_path, struct super_block *sb, int xid)
{
	int rc = 0;
	FILE_UNIX_BASIC_INFO findData;
	struct cifsTconInfo *pTcon;
	struct inode *inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	char *tmp_path;

	pTcon = cifs_sb->tcon;
43
	cFYI(1, ("Getting info on %s", search_path));
Linus Torvalds's avatar
Linus Torvalds committed
44 45
	/* could have done a find first instead but this returns more info */
	rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
46 47
				  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55 56
/*	dump_mem("\nUnixQPathInfo return data", &findData,
		 sizeof(findData)); */
	if (rc) {
		if (rc == -EREMOTE) {
			tmp_path =
			    kmalloc(strnlen(pTcon->treeName,
					    MAX_TREE_SIZE + 1) +
				    strnlen(search_path, MAX_PATHCONF) + 1,
				    GFP_KERNEL);
57
			if (tmp_path == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
58
				return -ENOMEM;
59

Steve French's avatar
Steve French committed
60
			/* have to skip first of the double backslash of
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65
			   UNC name */
			strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
			strncat(tmp_path, search_path, MAX_PATHCONF);
			rc = connect_to_dfs_path(xid, pTcon->ses,
						 /* treename + */ tmp_path,
Steve French's avatar
Steve French committed
66 67
						 cifs_sb->local_nls,
						 cifs_sb->mnt_cifs_flags &
68
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
			kfree(tmp_path);

			/* BB fix up inode etc. */
		} else if (rc) {
			return rc;
		}
	} else {
		struct cifsInodeInfo *cifsInfo;
		__u32 type = le32_to_cpu(findData.Type);
		__u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
		__u64 end_of_file = le64_to_cpu(findData.EndOfFile);

		/* get new inode */
		if (*pinode == NULL) {
			*pinode = new_inode(sb);
Steve French's avatar
Steve French committed
84
			if (*pinode == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87 88
				return -ENOMEM;
			/* 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? */
89
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92
				(*pinode)->i_ino =
					(unsigned long)findData.UniqueId;
			} /* note ino incremented to unique num in new_inode */
93
			if (sb->s_flags & MS_NOATIME)
94
				(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
95

Linus Torvalds's avatar
Linus Torvalds committed
96 97 98 99 100 101
			insert_inode_hash(*pinode);
		}

		inode = *pinode;
		cifsInfo = CIFS_I(inode);

102
		cFYI(1, ("Old time %ld", cifsInfo->time));
Linus Torvalds's avatar
Linus Torvalds committed
103
		cifsInfo->time = jiffies;
104
		cFYI(1, ("New time %ld", cifsInfo->time));
Linus Torvalds's avatar
Linus Torvalds committed
105
		/* this is ok to set on every inode revalidate */
Steve French's avatar
Steve French committed
106
		atomic_set(&cifsInfo->inUse, 1);
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109 110 111 112 113 114 115

		inode->i_atime =
		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
		inode->i_mtime =
		    cifs_NTtimeToUnix(le64_to_cpu
				(findData.LastModificationTime));
		inode->i_ctime =
		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
		inode->i_mode = le64_to_cpu(findData.Permissions);
116
		/* since we set the inode type below we need to mask off
Steve French's avatar
Steve French committed
117
		   to avoid strange results if bits set above */
118
		inode->i_mode &= ~S_IFMT;
Linus Torvalds's avatar
Linus Torvalds committed
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
		if (type == UNIX_FILE) {
			inode->i_mode |= S_IFREG;
		} else if (type == UNIX_SYMLINK) {
			inode->i_mode |= S_IFLNK;
		} else if (type == UNIX_DIR) {
			inode->i_mode |= S_IFDIR;
		} else if (type == UNIX_CHARDEV) {
			inode->i_mode |= S_IFCHR;
			inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
				le64_to_cpu(findData.DevMinor) & MINORMASK);
		} else if (type == UNIX_BLOCKDEV) {
			inode->i_mode |= S_IFBLK;
			inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
				le64_to_cpu(findData.DevMinor) & MINORMASK);
		} else if (type == UNIX_FIFO) {
			inode->i_mode |= S_IFIFO;
		} else if (type == UNIX_SOCKET) {
			inode->i_mode |= S_IFSOCK;
137 138 139
		} else {
			/* safest to call it a file if we do not know */
			inode->i_mode |= S_IFREG;
Steve French's avatar
Steve French committed
140
			cFYI(1, ("unknown type %d", type));
Linus Torvalds's avatar
Linus Torvalds committed
141
		}
142

143 144 145 146 147 148 149 150 151
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
			inode->i_uid = cifs_sb->mnt_uid;
		else
			inode->i_uid = le64_to_cpu(findData.Uid);

		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
			inode->i_gid = cifs_sb->mnt_gid;
		else
			inode->i_gid = le64_to_cpu(findData.Gid);
152

Linus Torvalds's avatar
Linus Torvalds committed
153 154
		inode->i_nlink = le64_to_cpu(findData.Nlinks);

155
		spin_lock(&inode->i_lock);
156
		if (is_size_safe_to_change(cifsInfo, end_of_file)) {
Linus Torvalds's avatar
Linus Torvalds committed
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
		/* 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);

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

		/* This seems incredibly stupid but it turns out that i_blocks
		   is not related to (i_size / i_blksize), instead 512 byte size
		   is required for calculating num blocks */

		/* 512 bytes (2**9) is the fake blocksize that must be used */
		/* for this calculation */
			inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
		}
174
		spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
175 176

		if (num_of_bytes < end_of_file)
177
			cFYI(1, ("allocation size less than end of file"));
178 179 180
		cFYI(1, ("Size %ld and blocks %llu",
			(unsigned long) inode->i_size,
			(unsigned long long)inode->i_blocks));
Linus Torvalds's avatar
Linus Torvalds committed
181
		if (S_ISREG(inode->i_mode)) {
182
			cFYI(1, ("File inode"));
Linus Torvalds's avatar
Linus Torvalds committed
183
			inode->i_op = &cifs_file_inode_ops;
184 185
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
				if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
Steve French's avatar
Steve French committed
186
					inode->i_fop =
187 188 189
						&cifs_file_direct_nobrl_ops;
				else
					inode->i_fop = &cifs_file_direct_ops;
190
			} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
191
				inode->i_fop = &cifs_file_nobrl_ops;
Steve French's avatar
Steve French committed
192
			else /* not direct, send byte range locks */
Linus Torvalds's avatar
Linus Torvalds committed
193
				inode->i_fop = &cifs_file_ops;
194

195
			/* check if server can support readpages */
Steve French's avatar
Steve French committed
196
			if (pTcon->ses->server->maxBuf <
Dave Kleikamp's avatar
Dave Kleikamp committed
197 198 199 200
			    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;
Linus Torvalds's avatar
Linus Torvalds committed
201
		} else if (S_ISDIR(inode->i_mode)) {
202
			cFYI(1, ("Directory inode"));
Linus Torvalds's avatar
Linus Torvalds committed
203 204 205
			inode->i_op = &cifs_dir_inode_ops;
			inode->i_fop = &cifs_dir_ops;
		} else if (S_ISLNK(inode->i_mode)) {
206
			cFYI(1, ("Symbolic Link inode"));
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209
			inode->i_op = &cifs_symlink_inode_ops;
		/* tmp_inode->i_fop = */ /* do not need to set to anything */
		} else {
210
			cFYI(1, ("Init special inode"));
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214 215 216 217
			init_special_inode(inode, inode->i_mode,
					   inode->i_rdev);
		}
	}
	return rc;
}

Steve French's avatar
Steve French committed
218
static int decode_sfu_inode(struct inode *inode, __u64 size,
219 220 221 222 223 224 225
			    const unsigned char *path,
			    struct cifs_sb_info *cifs_sb, int xid)
{
	int rc;
	int oplock = FALSE;
	__u16 netfid;
	struct cifsTconInfo *pTcon = cifs_sb->tcon;
226
	char buf[24];
227
	unsigned int bytes_read;
Steve French's avatar
Steve French committed
228
	char *pbuf;
229 230 231

	pbuf = buf;

232
	if (size == 0) {
233 234 235 236 237
		inode->i_mode |= S_IFIFO;
		return 0;
	} else if (size < 8) {
		return -EINVAL;	 /* EOPNOTSUPP? */
	}
238

239 240 241 242 243
	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);
Steve French's avatar
Steve French committed
244
	if (rc == 0) {
245
		int buf_type = CIFS_NO_BUFFER;
246 247
			/* Read header */
		rc = CIFSSMBRead(xid, pTcon,
Steve French's avatar
Steve French committed
248
				 netfid,
249
				 24 /* length */, 0 /* offset */,
250
				 &bytes_read, &pbuf, &buf_type);
251 252
		if ((rc == 0) && (bytes_read >= 8)) {
			if (memcmp("IntxBLK", pbuf, 8) == 0) {
Steve French's avatar
Steve French committed
253
				cFYI(1, ("Block device"));
254
				inode->i_mode |= S_IFBLK;
255
				if (bytes_read == 24) {
256 257 258 259 260 261 262
					/* 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);
				}
263
			} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Steve French's avatar
Steve French committed
264
				cFYI(1, ("Char device"));
265
				inode->i_mode |= S_IFCHR;
266
				if (bytes_read == 24) {
267 268 269 270 271 272
					/* 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);
Steve French's avatar
Steve French committed
273
				}
274
			} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Steve French's avatar
Steve French committed
275
				cFYI(1, ("Symlink"));
276
				inode->i_mode |= S_IFLNK;
277 278
			} else {
				inode->i_mode |= S_IFREG; /* file? */
Steve French's avatar
Steve French committed
279
				rc = -EOPNOTSUPP;
280
			}
281 282
		} else {
			inode->i_mode |= S_IFREG; /* then it is a file */
Steve French's avatar
Steve French committed
283 284
			rc = -EOPNOTSUPP; /* or some unknown SFU type */
		}
285 286 287 288 289
		CIFSSMBClose(xid, pTcon, netfid);
	}
	return rc;
}

290 291
#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */

292
static int get_sfu_mode(struct inode *inode,
293 294 295
			const unsigned char *path,
			struct cifs_sb_info *cifs_sb, int xid)
{
296
#ifdef CONFIG_CIFS_XATTR
297 298 299 300 301 302
	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,
Steve French's avatar
Steve French committed
303
		cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
304
	if (rc < 0)
305 306 307
		return (int)rc;
	else if (rc > 3) {
		mode = le32_to_cpu(*((__le32 *)ea_value));
Steve French's avatar
Steve French committed
308 309
		inode->i_mode &= ~SFBITS_MASK;
		cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
310
		inode->i_mode = (mode &  SFBITS_MASK) | inode->i_mode;
Steve French's avatar
Steve French committed
311
		cFYI(1, ("special mode bits 0%o", mode));
312 313 314 315
		return 0;
	} else {
		return 0;
	}
316 317 318
#else
	return -EOPNOTSUPP;
#endif
319 320
}

Linus Torvalds's avatar
Linus Torvalds committed
321 322 323 324 325 326 327 328 329 330
int cifs_get_inode_info(struct inode **pinode,
	const unsigned char *search_path, FILE_ALL_INFO *pfindData,
	struct super_block *sb, int xid)
{
	int rc = 0;
	struct cifsTconInfo *pTcon;
	struct inode *inode;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	char *tmp_path;
	char *buf = NULL;
331
	int adjustTZ = FALSE;
Linus Torvalds's avatar
Linus Torvalds committed
332 333

	pTcon = cifs_sb->tcon;
Steve French's avatar
Steve French committed
334
	cFYI(1, ("Getting info on %s", search_path));
Linus Torvalds's avatar
Linus Torvalds committed
335

336 337
	if ((pfindData == NULL) && (*pinode != NULL)) {
		if (CIFS_I(*pinode)->clientCanCacheRead) {
Steve French's avatar
Steve French committed
338
			cFYI(1, ("No need to revalidate cached inode sizes"));
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343
			return rc;
		}
	}

	/* if file info not passed in then get it from server */
344
	if (pfindData == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
345
		buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
346
		if (buf == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349 350
			return -ENOMEM;
		pfindData = (FILE_ALL_INFO *)buf;
		/* could do find first instead but this returns more info */
		rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
351
			      0 /* not legacy */,
352
			      cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
353
				CIFS_MOUNT_MAP_SPECIAL_CHR);
354 355 356
		/* 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 */
357
		if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
358
			rc = SMBQueryInformation(xid, pTcon, search_path,
Steve French's avatar
Steve French committed
359
					pfindData, cifs_sb->local_nls,
360 361
					cifs_sb->mnt_cifs_flags &
					  CIFS_MOUNT_MAP_SPECIAL_CHR);
362
			adjustTZ = TRUE;
363
		}
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
	}
	/* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
	if (rc) {
		if (rc == -EREMOTE) {
			tmp_path =
			    kmalloc(strnlen
				    (pTcon->treeName,
				     MAX_TREE_SIZE + 1) +
				    strnlen(search_path, MAX_PATHCONF) + 1,
				    GFP_KERNEL);
			if (tmp_path == NULL) {
				kfree(buf);
				return -ENOMEM;
			}

			strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
			strncat(tmp_path, search_path, MAX_PATHCONF);
			rc = connect_to_dfs_path(xid, pTcon->ses,
						 /* treename + */ tmp_path,
Steve French's avatar
Steve French committed
383 384
						 cifs_sb->local_nls,
						 cifs_sb->mnt_cifs_flags &
385
						   CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
386 387 388 389 390 391 392 393 394 395 396 397 398
			kfree(tmp_path);
			/* BB fix up inode etc. */
		} else if (rc) {
			kfree(buf);
			return rc;
		}
	} else {
		struct cifsInodeInfo *cifsInfo;
		__u32 attr = le32_to_cpu(pfindData->Attributes);

		/* get new inode */
		if (*pinode == NULL) {
			*pinode = new_inode(sb);
399 400
			if (*pinode == NULL) {
				kfree(buf);
Linus Torvalds's avatar
Linus Torvalds committed
401
				return -ENOMEM;
402
			}
Linus Torvalds's avatar
Linus Torvalds committed
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
			/* 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? */

Steve French's avatar
Steve French committed
418
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Linus Torvalds's avatar
Linus Torvalds committed
419 420 421
				int rc1 = 0;
				__u64 inode_num;

Steve French's avatar
Steve French committed
422 423
				rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
					search_path, &inode_num,
424 425 426
					cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
427
				if (rc1) {
Steve French's avatar
Steve French committed
428
					cFYI(1, ("GetSrvInodeNum rc %d", rc1));
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432
					/* 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*/
433
			if (sb->s_flags & MS_NOATIME)
434
				(*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439
			insert_inode_hash(*pinode);
		}
		inode = *pinode;
		cifsInfo = CIFS_I(inode);
		cifsInfo->cifsAttrs = attr;
440
		cFYI(1, ("Old time %ld", cifsInfo->time));
Linus Torvalds's avatar
Linus Torvalds committed
441
		cifsInfo->time = jiffies;
442
		cFYI(1, ("New time %ld", cifsInfo->time));
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445 446 447 448

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

449
		/* Linux can not store file creation time so ignore it */
450
		if (pfindData->LastAccessTime)
451 452 453 454
			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;
Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458
		inode->i_mtime =
		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
		inode->i_ctime =
		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
459
		cFYI(0, ("Attributes came in as 0x%x", attr));
460
		if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
461
			inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
Steve French's avatar
Steve French committed
462
			inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
463
		}
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468

		/* 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;
469
		else /* since we set the inode type below we need to mask off
Steve French's avatar
Steve French committed
470 471 472
		     to avoid strange results if type changes and both
		     get orred in */
			inode->i_mode &= ~S_IFMT;
Linus Torvalds's avatar
Linus Torvalds committed
473 474 475 476 477 478 479 480
/*		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;
481 482 483 484 485 486
		} 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;
487 488 489
/* BB Finish for SFU style symlinks and devices */
		} else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
			   (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
Steve French's avatar
Steve French committed
490
			if (decode_sfu_inode(inode,
491 492 493
					 le64_to_cpu(pfindData->EndOfFile),
					 search_path,
					 cifs_sb, xid)) {
Steve French's avatar
Steve French committed
494
				cFYI(1, ("Unrecognized sfu inode type"));
495
			}
Steve French's avatar
Steve French committed
496
			cFYI(1, ("sfu mode 0%o", inode->i_mode));
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499 500 501 502
		} else {
			inode->i_mode |= S_IFREG;
			/* treat the dos attribute of read-only as read-only
			   mode e.g. 555 */
			if (cifsInfo->cifsAttrs & ATTR_READONLY)
				inode->i_mode &= ~(S_IWUGO);
503 504 505 506 507 508
			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);
Linus Torvalds's avatar
Linus Torvalds committed
509 510 511
		/* BB add code here -
		   validate if device or weird share or device type? */
		}
512

513
		spin_lock(&inode->i_lock);
514 515
		if (is_size_safe_to_change(cifsInfo,
					   le64_to_cpu(pfindData->EndOfFile))) {
516
			/* can not safely shrink the file size here if the
Linus Torvalds's avatar
Linus Torvalds committed
517
			   client is writing to it due to potential races */
Steve French's avatar
Steve French committed
518
			i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521 522 523 524

			/* 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;
		}
525
		spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
526 527 528

		inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);

Steve French's avatar
Steve French committed
529
		/* BB fill in uid and gid here? with help from winbind?
Linus Torvalds's avatar
Linus Torvalds committed
530
		   or retrieve from NTFS stream extended attribute */
Steve French's avatar
Steve French committed
531
#ifdef CONFIG_CIFS_EXPERIMENTAL
532
		/* fill in 0777 bits from ACL */
Steve French's avatar
Steve French committed
533 534
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
			cFYI(1, ("Getting mode bits from ACL"));
Steve French's avatar
Steve French committed
535
			acl_to_uid_mode(inode, search_path);
Steve French's avatar
Steve French committed
536 537
		}
#endif
538
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
539 540
			/* fill in remaining high mode bits e.g. SUID, VTX */
			get_sfu_mode(inode, search_path, cifs_sb, xid);
541
		} else if (atomic_read(&cifsInfo->inUse) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545
			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 */
Steve French's avatar
Steve French committed
546
			atomic_set(&cifsInfo->inUse, 1);
Linus Torvalds's avatar
Linus Torvalds committed
547 548 549
		}

		if (S_ISREG(inode->i_mode)) {
550
			cFYI(1, ("File inode"));
Linus Torvalds's avatar
Linus Torvalds committed
551
			inode->i_op = &cifs_file_inode_ops;
552 553 554 555 556 557
			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;
558
			} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
559 560
				inode->i_fop = &cifs_file_nobrl_ops;
			else /* not direct, send byte range locks */
Linus Torvalds's avatar
Linus Torvalds committed
561
				inode->i_fop = &cifs_file_ops;
562

Steve French's avatar
Steve French committed
563
			if (pTcon->ses->server->maxBuf <
Dave Kleikamp's avatar
Dave Kleikamp committed
564 565 566 567
			     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;
Linus Torvalds's avatar
Linus Torvalds committed
568
		} else if (S_ISDIR(inode->i_mode)) {
569
			cFYI(1, ("Directory inode"));
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572
			inode->i_op = &cifs_dir_inode_ops;
			inode->i_fop = &cifs_dir_ops;
		} else if (S_ISLNK(inode->i_mode)) {
573
			cFYI(1, ("Symbolic Link inode"));
Linus Torvalds's avatar
Linus Torvalds committed
574 575 576 577 578 579 580 581 582 583
			inode->i_op = &cifs_symlink_inode_ops;
		} else {
			init_special_inode(inode, inode->i_mode,
					   inode->i_rdev);
		}
	}
	kfree(buf);
	return rc;
}

584 585 586 587
static const struct inode_operations cifs_ipc_inode_ops = {
	.lookup = cifs_lookup,
};

Linus Torvalds's avatar
Linus Torvalds committed
588 589 590
/* gets root inode */
void cifs_read_inode(struct inode *inode)
{
591
	int xid, rc;
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594 595
	struct cifs_sb_info *cifs_sb;

	cifs_sb = CIFS_SB(inode->i_sb);
	xid = GetXid();
596 597

	if (cifs_sb->tcon->unix_ext)
598
		rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
Linus Torvalds's avatar
Linus Torvalds committed
599
	else
600 601 602 603 604 605 606 607 608 609 610
		rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
	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;
	}

Linus Torvalds's avatar
Linus Torvalds committed
611 612 613 614 615 616 617 618 619 620 621 622 623 624
	/* can not call macro FreeXid here since in a void func */
	_FreeXid(xid);
}

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;

625
	cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
Linus Torvalds's avatar
Linus Torvalds committed
626 627 628

	xid = GetXid();

629
	if (inode)
630 631
		cifs_sb = CIFS_SB(inode->i_sb);
	else
632
		cifs_sb = CIFS_SB(direntry->d_sb);
Linus Torvalds's avatar
Linus Torvalds committed
633 634 635 636
	pTcon = cifs_sb->tcon;

	/* Unlink can be called from rename so we can not grab the sem here
	   since we deadlock otherwise */
637
/*	mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
638
	full_path = build_path_from_dentry(direntry);
639
/*	mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
Linus Torvalds's avatar
Linus Torvalds committed
640 641 642 643
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
644 645 646 647 648 649

	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,
650
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
651 652 653 654
		cFYI(1, ("posix del rc %d", rc));
		if ((rc == 0) || (rc == -ENOENT))
			goto psx_del_no_retry;
	}
Linus Torvalds's avatar
Linus Torvalds committed
655

656 657 658
	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
psx_del_no_retry:
Linus Torvalds's avatar
Linus Torvalds committed
659
	if (!rc) {
660
		if (direntry->d_inode)
661
			drop_nlink(direntry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
662 663 664 665 666 667 668 669
	} else if (rc == -ENOENT) {
		d_drop(direntry);
	} else if (rc == -ETXTBSY) {
		int oplock = FALSE;
		__u16 netfid;

		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
				 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
670
				 &netfid, &oplock, NULL, cifs_sb->local_nls,
Steve French's avatar
Steve French committed
671
				 cifs_sb->mnt_cifs_flags &
672
					CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French's avatar
Steve French committed
673
		if (rc == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
674
			CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
Steve French's avatar
Steve French committed
675 676
					      cifs_sb->local_nls,
					      cifs_sb->mnt_cifs_flags &
677
						CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
678
			CIFSSMBClose(xid, pTcon, netfid);
679
			if (direntry->d_inode)
680
				drop_nlink(direntry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
681 682 683
		}
	} else if (rc == -EACCES) {
		/* try only if r/o attribute set in local lookup data? */
684
		pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
685 686 687 688 689 690
		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,
691
						     cifs_sb->local_nls,
Steve French's avatar
Steve French committed
692
						     cifs_sb->mnt_cifs_flags &
693
							CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
694 695 696 697 698 699 700 701 702
			else
				rc = -EOPNOTSUPP;

			if (rc == -EOPNOTSUPP) {
				int oplock = FALSE;
				__u16 netfid;
			/*	rc = CIFSSMBSetAttrLegacy(xid, pTcon,
							  full_path,
							  (__u16)ATTR_NORMAL,
Steve French's avatar
Steve French committed
703
							  cifs_sb->local_nls);
Linus Torvalds's avatar
Linus Torvalds committed
704 705 706 707 708 709 710 711 712 713 714
			   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,
715
						 cifs_sb->local_nls,
Steve French's avatar
Steve French committed
716
						 cifs_sb->mnt_cifs_flags &
717
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French's avatar
Steve French committed
718
				if (rc == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
719 720 721 722 723 724 725 726
					rc = CIFSSMBSetFileTimes(xid, pTcon,
								 pinfo_buf,
								 netfid);
					CIFSSMBClose(xid, pTcon, netfid);
				}
			}
			kfree(pinfo_buf);
		}
Steve French's avatar
Steve French committed
727 728 729 730
		if (rc == 0) {
			rc = CIFSSMBDelFile(xid, pTcon, full_path,
					    cifs_sb->local_nls,
					    cifs_sb->mnt_cifs_flags &
731
						CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
732
			if (!rc) {
733
				if (direntry->d_inode)
734
					drop_nlink(direntry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
735 736 737 738 739 740 741 742 743
			} else if (rc == -ETXTBSY) {
				int oplock = FALSE;
				__u16 netfid;

				rc = CIFSSMBOpen(xid, pTcon, full_path,
						 FILE_OPEN, DELETE,
						 CREATE_NOT_DIR |
						 CREATE_DELETE_ON_CLOSE,
						 &netfid, &oplock, NULL,
Steve French's avatar
Steve French committed
744 745
						 cifs_sb->local_nls,
						 cifs_sb->mnt_cifs_flags &
746
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French's avatar
Steve French committed
747
				if (rc == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
748 749
					CIFSSMBRenameOpenFile(xid, pTcon,
						netfid, NULL,
750 751 752
						cifs_sb->local_nls,
						cifs_sb->mnt_cifs_flags &
						    CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds's avatar
Linus Torvalds committed
753
					CIFSSMBClose(xid, pTcon, netfid);
754
					if (direntry->d_inode)
755
						drop_nlink(direntry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
756 757 758 759 760
				}
			/* BB if rc = -ETXTBUSY goto the rename logic BB */
			}
		}
	}
761
	if (direntry->d_inode) {
762 763 764 765 766
		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);
	}
767
	if (inode) {
768 769 770 771
		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 */
	}
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774 775 776 777

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

778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
static void posix_fill_in_inode(struct inode *tmp_inode,
	FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
{
	loff_t local_size;
	struct timespec local_mtime;

	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);

	__u32 type = le32_to_cpu(pData->Type);
	__u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
	__u64 end_of_file = le64_to_cpu(pData->EndOfFile);
	cifsInfo->time = jiffies;
	atomic_inc(&cifsInfo->inUse);

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

	tmp_inode->i_atime =
	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
	tmp_inode->i_mtime =
	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
	tmp_inode->i_ctime =
	    cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));

	tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
	/* since we set the inode type below we need to mask off type
Steve French's avatar
Steve French committed
806 807
	   to avoid strange results if bits above were corrupt */
	tmp_inode->i_mode &= ~S_IFMT;
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
	if (type == UNIX_FILE) {
		*pobject_type = DT_REG;
		tmp_inode->i_mode |= S_IFREG;
	} else if (type == UNIX_SYMLINK) {
		*pobject_type = DT_LNK;
		tmp_inode->i_mode |= S_IFLNK;
	} else if (type == UNIX_DIR) {
		*pobject_type = DT_DIR;
		tmp_inode->i_mode |= S_IFDIR;
	} else if (type == UNIX_CHARDEV) {
		*pobject_type = DT_CHR;
		tmp_inode->i_mode |= S_IFCHR;
		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
				le64_to_cpu(pData->DevMinor) & MINORMASK);
	} else if (type == UNIX_BLOCKDEV) {
		*pobject_type = DT_BLK;
		tmp_inode->i_mode |= S_IFBLK;
		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
				le64_to_cpu(pData->DevMinor) & MINORMASK);
	} else if (type == UNIX_FIFO) {
		*pobject_type = DT_FIFO;
		tmp_inode->i_mode |= S_IFIFO;
	} else if (type == UNIX_SOCKET) {
		*pobject_type = DT_SOCK;
		tmp_inode->i_mode |= S_IFSOCK;
	} else {
		/* safest to just call it a file */
		*pobject_type = DT_REG;
		tmp_inode->i_mode |= S_IFREG;
Steve French's avatar
Steve French committed
837
		cFYI(1, ("unknown inode type %d", type));
838 839
	}

840
#ifdef CONFIG_CIFS_DEBUG2
Steve French's avatar
Steve French committed
841
	cFYI(1, ("object type: %d", type));
842
#endif
843 844 845 846 847 848
	tmp_inode->i_uid = le64_to_cpu(pData->Uid);
	tmp_inode->i_gid = le64_to_cpu(pData->Gid);
	tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);

	spin_lock(&tmp_inode->i_lock);
	if (is_size_safe_to_change(cifsInfo, end_of_file)) {
Steve French's avatar
Steve French committed
849
		/* can not safely change the file size here if the
850 851 852 853 854 855 856 857 858 859 860 861 862
		client is writing to it due to potential races */
		i_size_write(tmp_inode, end_of_file);

	/* 512 bytes (2**9) is the fake blocksize that must be used */
	/* for this calculation, not the real blocksize */
		tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
	}
	spin_unlock(&tmp_inode->i_lock);

	if (S_ISREG(tmp_inode->i_mode)) {
		cFYI(1, ("File inode"));
		tmp_inode->i_op = &cifs_file_inode_ops;

Steve French's avatar
Steve French committed
863 864
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
865 866 867
				tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
			else
				tmp_inode->i_fop = &cifs_file_direct_ops;
868

Steve French's avatar
Steve French committed
869
		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
870 871 872 873
			tmp_inode->i_fop = &cifs_file_nobrl_ops;
		else
			tmp_inode->i_fop = &cifs_file_ops;

Steve French's avatar
Steve French committed
874 875
		if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
		   (cifs_sb->tcon->ses->server->maxBuf <
876 877 878 879 880
			PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
			tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
		else
			tmp_inode->i_data.a_ops = &cifs_addr_ops;

Steve French's avatar
Steve French committed
881 882 883 884
		if (isNewInode)
			return; /* No sense invalidating pages for new inode
				   since we we have not started caching
				   readahead file data yet */
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902

		if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
			(local_size == tmp_inode->i_size)) {
			cFYI(1, ("inode exists but unchanged"));
		} else {
			/* file may have changed on server */
			cFYI(1, ("invalidate inode, readdir detected change"));
			invalidate_remote_inode(tmp_inode);
		}
	} else if (S_ISDIR(tmp_inode->i_mode)) {
		cFYI(1, ("Directory inode"));
		tmp_inode->i_op = &cifs_dir_inode_ops;
		tmp_inode->i_fop = &cifs_dir_ops;
	} else if (S_ISLNK(tmp_inode->i_mode)) {
		cFYI(1, ("Symbolic Link inode"));
		tmp_inode->i_op = &cifs_symlink_inode_ops;
/* tmp_inode->i_fop = *//* do not need to set to anything */
	} else {
Steve French's avatar
Steve French committed
903
		cFYI(1, ("Special inode"));
904 905
		init_special_inode(tmp_inode, tmp_inode->i_mode,
				   tmp_inode->i_rdev);
Steve French's avatar
Steve French committed
906
	}
907 908
}

Linus Torvalds's avatar
Linus Torvalds committed
909 910 911 912 913 914 915 916 917
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;

918
	cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
Linus Torvalds's avatar
Linus Torvalds committed
919 920 921 922 923 924

	xid = GetXid();

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

925
	full_path = build_path_from_dentry(direntry);
Linus Torvalds's avatar
Linus Torvalds committed
926 927 928 929
	if (full_path == NULL) {
		FreeXid(xid);
		return -ENOMEM;
	}
930

Steve French's avatar
Steve French committed
931 932
	if ((pTcon->ses->capabilities & CAP_UNIX) &&
		(CIFS_UNIX_POSIX_PATH_OPS_CAP &
933 934
			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
		u32 oplock = 0;
935
		FILE_UNIX_BASIC_INFO *pInfo =
936
			kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve French's avatar
Steve French committed
937
		if (pInfo == NULL) {
938 939 940
			rc = -ENOMEM;
			goto mkdir_out;
		}
941

942
		mode &= ~current->fs->umask;
943 944
		rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
				mode, NULL /* netfid */, pInfo, &oplock,
Steve French's avatar
Steve French committed
945 946
				full_path, cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
947
					CIFS_MOUNT_MAP_SPECIAL_CHR);
948 949 950 951
		if (rc == -EOPNOTSUPP) {
			kfree(pInfo);
			goto mkdir_retry_old;
		} else if (rc) {
952 953 954
			cFYI(1, ("posix mkdir returned 0x%x", rc));
			d_drop(direntry);
		} else {
955
			int obj_type;
956 957
			if (pInfo->Type == cpu_to_le32(-1)) {
				/* no return info, go query for it */
958
				kfree(pInfo);
Steve French's avatar
Steve French committed
959
				goto mkdir_get_info;
960
			}
Steve French's avatar
Steve French committed
961 962
/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
	to set uid/gid */
963 964 965 966 967
			inc_nlink(inode);
			if (pTcon->nocase)
				direntry->d_op = &cifs_ci_dentry_ops;
			else
				direntry->d_op = &cifs_dentry_ops;
968 969

			newinode = new_inode(inode->i_sb);
970 971
			if (newinode == NULL) {
				kfree(pInfo);
972
				goto mkdir_get_info;
973
			}
974 975 976 977 978 979 980
			/* 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 */
Steve French's avatar
Steve French committed
981
			if (inode->i_sb->s_flags & MS_NOATIME)
982 983 984 985
				newinode->i_flags |= S_NOATIME | S_NOCMTIME;
			newinode->i_nlink = 2;

			insert_inode_hash(newinode);
986
			d_instantiate(direntry, newinode);
987 988 989 990

			/* we already checked in POSIXCreate whether
			   frame was long enough */
			posix_fill_in_inode(direntry->d_inode,
991
					pInfo, &obj_type, 1 /* NewInode */);
992
#ifdef CONFIG_CIFS_DEBUG2
Steve French's avatar
Steve French committed
993
			cFYI(1, ("instantiated dentry %p %s to inode %p",
994 995
				direntry, direntry->d_name.name, newinode));

Steve French's avatar
Steve French committed
996 997
			if (newinode->i_nlink != 2)
				cFYI(1, ("unexpected number of links %d",
998 999
					newinode->i_nlink));
#endif
1000 1001 1002
		}
		kfree(pInfo);
		goto mkdir_out;
Steve French's avatar
Steve French committed
1003
	}
1004
mkdir_retry_old:
Linus Torvalds's avatar
Linus Torvalds committed
1005
	/* BB add setting the equivalent of mode via CreateX w/ACLs */