xref: /linux/fs/smb/client/inode.c (revision 1f20a5769446a1acae67ac9e63d07a594829a789)
1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2010
5  *   Author(s): Steve French (sfrench@us.ibm.com)
6  *
7  */
8 #include <linux/fs.h>
9 #include <linux/stat.h>
10 #include <linux/slab.h>
11 #include <linux/pagemap.h>
12 #include <linux/freezer.h>
13 #include <linux/sched/signal.h>
14 #include <linux/wait_bit.h>
15 #include <linux/fiemap.h>
16 #include <asm/div64.h>
17 #include "cifsfs.h"
18 #include "cifspdu.h"
19 #include "cifsglob.h"
20 #include "cifsproto.h"
21 #include "smb2proto.h"
22 #include "cifs_debug.h"
23 #include "cifs_fs_sb.h"
24 #include "cifs_unicode.h"
25 #include "fscache.h"
26 #include "fs_context.h"
27 #include "cifs_ioctl.h"
28 #include "cached_dir.h"
29 #include "reparse.h"
30 
31 static void cifs_set_ops(struct inode *inode)
32 {
33 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
34 
35 	switch (inode->i_mode & S_IFMT) {
36 	case S_IFREG:
37 		inode->i_op = &cifs_file_inode_ops;
38 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
39 			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
40 				inode->i_fop = &cifs_file_direct_nobrl_ops;
41 			else
42 				inode->i_fop = &cifs_file_direct_ops;
43 		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
44 			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
45 				inode->i_fop = &cifs_file_strict_nobrl_ops;
46 			else
47 				inode->i_fop = &cifs_file_strict_ops;
48 		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 			inode->i_fop = &cifs_file_nobrl_ops;
50 		else { /* not direct, send byte range locks */
51 			inode->i_fop = &cifs_file_ops;
52 		}
53 
54 		/* check if server can support readahead */
55 		if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
56 				PAGE_SIZE + MAX_CIFS_HDR_SIZE)
57 			inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
58 		else
59 			inode->i_data.a_ops = &cifs_addr_ops;
60 		break;
61 	case S_IFDIR:
62 		if (IS_AUTOMOUNT(inode)) {
63 			inode->i_op = &cifs_namespace_inode_operations;
64 		} else {
65 			inode->i_op = &cifs_dir_inode_ops;
66 			inode->i_fop = &cifs_dir_ops;
67 		}
68 		break;
69 	case S_IFLNK:
70 		inode->i_op = &cifs_symlink_inode_ops;
71 		break;
72 	default:
73 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
74 		break;
75 	}
76 }
77 
78 /* check inode attributes against fattr. If they don't match, tag the
79  * inode for cache invalidation
80  */
81 static void
82 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
83 {
84 	struct cifs_fscache_inode_coherency_data cd;
85 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
86 	struct timespec64 mtime;
87 
88 	cifs_dbg(FYI, "%s: revalidating inode %llu\n",
89 		 __func__, cifs_i->uniqueid);
90 
91 	if (inode->i_state & I_NEW) {
92 		cifs_dbg(FYI, "%s: inode %llu is new\n",
93 			 __func__, cifs_i->uniqueid);
94 		return;
95 	}
96 
97 	/* don't bother with revalidation if we have an oplock */
98 	if (CIFS_CACHE_READ(cifs_i)) {
99 		cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
100 			 __func__, cifs_i->uniqueid);
101 		return;
102 	}
103 
104 	 /* revalidate if mtime or size have changed */
105 	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
106 	mtime = inode_get_mtime(inode);
107 	if (timespec64_equal(&mtime, &fattr->cf_mtime) &&
108 	    cifs_i->netfs.remote_i_size == fattr->cf_eof) {
109 		cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
110 			 __func__, cifs_i->uniqueid);
111 		return;
112 	}
113 
114 	cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
115 		 __func__, cifs_i->uniqueid);
116 	set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
117 	/* Invalidate fscache cookie */
118 	cifs_fscache_fill_coherency(&cifs_i->netfs.inode, &cd);
119 	fscache_invalidate(cifs_inode_cookie(inode), &cd, i_size_read(inode), 0);
120 }
121 
122 /*
123  * copy nlink to the inode, unless it wasn't provided.  Provide
124  * sane values if we don't have an existing one and none was provided
125  */
126 static void
127 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
128 {
129 	/*
130 	 * if we're in a situation where we can't trust what we
131 	 * got from the server (readdir, some non-unix cases)
132 	 * fake reasonable values
133 	 */
134 	if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
135 		/* only provide fake values on a new inode */
136 		if (inode->i_state & I_NEW) {
137 			if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
138 				set_nlink(inode, 2);
139 			else
140 				set_nlink(inode, 1);
141 		}
142 		return;
143 	}
144 
145 	/* we trust the server, so update it */
146 	set_nlink(inode, fattr->cf_nlink);
147 }
148 
149 /* populate an inode with info from a cifs_fattr struct */
150 int
151 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,
152 		    bool from_readdir)
153 {
154 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
155 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
156 
157 	if (!(inode->i_state & I_NEW) &&
158 	    unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
159 		CIFS_I(inode)->time = 0; /* force reval */
160 		return -ESTALE;
161 	}
162 
163 	cifs_revalidate_cache(inode, fattr);
164 
165 	spin_lock(&inode->i_lock);
166 	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
167 	fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
168 	fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
169 	/* we do not want atime to be less than mtime, it broke some apps */
170 	if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
171 		inode_set_atime_to_ts(inode, fattr->cf_mtime);
172 	else
173 		inode_set_atime_to_ts(inode, fattr->cf_atime);
174 	inode_set_mtime_to_ts(inode, fattr->cf_mtime);
175 	inode_set_ctime_to_ts(inode, fattr->cf_ctime);
176 	inode->i_rdev = fattr->cf_rdev;
177 	cifs_nlink_fattr_to_inode(inode, fattr);
178 	inode->i_uid = fattr->cf_uid;
179 	inode->i_gid = fattr->cf_gid;
180 
181 	/* if dynperm is set, don't clobber existing mode */
182 	if (inode->i_state & I_NEW ||
183 	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
184 		inode->i_mode = fattr->cf_mode;
185 
186 	cifs_i->cifsAttrs = fattr->cf_cifsattrs;
187 	cifs_i->reparse_tag = fattr->cf_cifstag;
188 
189 	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
190 		cifs_i->time = 0;
191 	else
192 		cifs_i->time = jiffies;
193 
194 	if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
195 		set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
196 	else
197 		clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
198 
199 	cifs_i->netfs.remote_i_size = fattr->cf_eof;
200 	/*
201 	 * Can't safely change the file size here if the client is writing to
202 	 * it due to potential races.
203 	 */
204 	if (is_size_safe_to_change(cifs_i, fattr->cf_eof, from_readdir)) {
205 		i_size_write(inode, fattr->cf_eof);
206 
207 		/*
208 		 * i_blocks is not related to (i_size / i_blksize),
209 		 * but instead 512 byte (2**9) size is required for
210 		 * calculating num blocks.
211 		 */
212 		inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
213 	}
214 
215 	if (S_ISLNK(fattr->cf_mode) && fattr->cf_symlink_target) {
216 		kfree(cifs_i->symlink_target);
217 		cifs_i->symlink_target = fattr->cf_symlink_target;
218 		fattr->cf_symlink_target = NULL;
219 	}
220 	spin_unlock(&inode->i_lock);
221 
222 	if (fattr->cf_flags & CIFS_FATTR_JUNCTION)
223 		inode->i_flags |= S_AUTOMOUNT;
224 	if (inode->i_state & I_NEW)
225 		cifs_set_ops(inode);
226 	return 0;
227 }
228 
229 void
230 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
231 {
232 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
233 
234 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
235 		return;
236 
237 	fattr->cf_uniqueid = iunique(sb, ROOT_I);
238 }
239 
240 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
241 void
242 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
243 			 struct cifs_sb_info *cifs_sb)
244 {
245 	memset(fattr, 0, sizeof(*fattr));
246 	fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
247 	fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
248 	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
249 
250 	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
251 	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
252 	fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
253 	/* old POSIX extensions don't get create time */
254 
255 	fattr->cf_mode = le64_to_cpu(info->Permissions);
256 
257 	/*
258 	 * Since we set the inode type below we need to mask off
259 	 * to avoid strange results if bits set above.
260 	 */
261 	fattr->cf_mode &= ~S_IFMT;
262 	switch (le32_to_cpu(info->Type)) {
263 	case UNIX_FILE:
264 		fattr->cf_mode |= S_IFREG;
265 		fattr->cf_dtype = DT_REG;
266 		break;
267 	case UNIX_SYMLINK:
268 		fattr->cf_mode |= S_IFLNK;
269 		fattr->cf_dtype = DT_LNK;
270 		break;
271 	case UNIX_DIR:
272 		fattr->cf_mode |= S_IFDIR;
273 		fattr->cf_dtype = DT_DIR;
274 		break;
275 	case UNIX_CHARDEV:
276 		fattr->cf_mode |= S_IFCHR;
277 		fattr->cf_dtype = DT_CHR;
278 		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
279 				       le64_to_cpu(info->DevMinor) & MINORMASK);
280 		break;
281 	case UNIX_BLOCKDEV:
282 		fattr->cf_mode |= S_IFBLK;
283 		fattr->cf_dtype = DT_BLK;
284 		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
285 				       le64_to_cpu(info->DevMinor) & MINORMASK);
286 		break;
287 	case UNIX_FIFO:
288 		fattr->cf_mode |= S_IFIFO;
289 		fattr->cf_dtype = DT_FIFO;
290 		break;
291 	case UNIX_SOCKET:
292 		fattr->cf_mode |= S_IFSOCK;
293 		fattr->cf_dtype = DT_SOCK;
294 		break;
295 	default:
296 		/* safest to call it a file if we do not know */
297 		fattr->cf_mode |= S_IFREG;
298 		fattr->cf_dtype = DT_REG;
299 		cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
300 		break;
301 	}
302 
303 	fattr->cf_uid = cifs_sb->ctx->linux_uid;
304 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
305 		u64 id = le64_to_cpu(info->Uid);
306 		if (id < ((uid_t)-1)) {
307 			kuid_t uid = make_kuid(&init_user_ns, id);
308 			if (uid_valid(uid))
309 				fattr->cf_uid = uid;
310 		}
311 	}
312 
313 	fattr->cf_gid = cifs_sb->ctx->linux_gid;
314 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
315 		u64 id = le64_to_cpu(info->Gid);
316 		if (id < ((gid_t)-1)) {
317 			kgid_t gid = make_kgid(&init_user_ns, id);
318 			if (gid_valid(gid))
319 				fattr->cf_gid = gid;
320 		}
321 	}
322 
323 	fattr->cf_nlink = le64_to_cpu(info->Nlinks);
324 }
325 
326 /*
327  * Fill a cifs_fattr struct with fake inode info.
328  *
329  * Needed to setup cifs_fattr data for the directory which is the
330  * junction to the new submount (ie to setup the fake directory
331  * which represents a DFS referral or reparse mount point).
332  */
333 static void cifs_create_junction_fattr(struct cifs_fattr *fattr,
334 				       struct super_block *sb)
335 {
336 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
337 
338 	cifs_dbg(FYI, "%s: creating fake fattr\n", __func__);
339 
340 	memset(fattr, 0, sizeof(*fattr));
341 	fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
342 	fattr->cf_uid = cifs_sb->ctx->linux_uid;
343 	fattr->cf_gid = cifs_sb->ctx->linux_gid;
344 	ktime_get_coarse_real_ts64(&fattr->cf_mtime);
345 	fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
346 	fattr->cf_nlink = 2;
347 	fattr->cf_flags = CIFS_FATTR_JUNCTION;
348 }
349 
350 /* Update inode with final fattr data */
351 static int update_inode_info(struct super_block *sb,
352 			     struct cifs_fattr *fattr,
353 			     struct inode **inode)
354 {
355 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
356 	int rc = 0;
357 
358 	if (!*inode) {
359 		*inode = cifs_iget(sb, fattr);
360 		if (!*inode)
361 			rc = -ENOMEM;
362 		return rc;
363 	}
364 	/* We already have inode, update it.
365 	 *
366 	 * If file type or uniqueid is different, return error.
367 	 */
368 	if (unlikely((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
369 		     CIFS_I(*inode)->uniqueid != fattr->cf_uniqueid)) {
370 		CIFS_I(*inode)->time = 0; /* force reval */
371 		return -ESTALE;
372 	}
373 	return cifs_fattr_to_inode(*inode, fattr, false);
374 }
375 
376 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
377 static int
378 cifs_get_file_info_unix(struct file *filp)
379 {
380 	int rc;
381 	unsigned int xid;
382 	FILE_UNIX_BASIC_INFO find_data;
383 	struct cifs_fattr fattr = {};
384 	struct inode *inode = file_inode(filp);
385 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
386 	struct cifsFileInfo *cfile = filp->private_data;
387 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
388 
389 	xid = get_xid();
390 
391 	if (cfile->symlink_target) {
392 		fattr.cf_symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
393 		if (!fattr.cf_symlink_target) {
394 			rc = -ENOMEM;
395 			goto cifs_gfiunix_out;
396 		}
397 	}
398 
399 	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
400 	if (!rc) {
401 		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
402 	} else if (rc == -EREMOTE) {
403 		cifs_create_junction_fattr(&fattr, inode->i_sb);
404 	} else
405 		goto cifs_gfiunix_out;
406 
407 	rc = cifs_fattr_to_inode(inode, &fattr, false);
408 
409 cifs_gfiunix_out:
410 	free_xid(xid);
411 	return rc;
412 }
413 
414 static int cifs_get_unix_fattr(const unsigned char *full_path,
415 			       struct super_block *sb,
416 			       struct cifs_fattr *fattr,
417 			       struct inode **pinode,
418 			       const unsigned int xid)
419 {
420 	struct TCP_Server_Info *server;
421 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
422 	FILE_UNIX_BASIC_INFO find_data;
423 	struct cifs_tcon *tcon;
424 	struct tcon_link *tlink;
425 	int rc, tmprc;
426 
427 	cifs_dbg(FYI, "Getting info on %s\n", full_path);
428 
429 	tlink = cifs_sb_tlink(cifs_sb);
430 	if (IS_ERR(tlink))
431 		return PTR_ERR(tlink);
432 	tcon = tlink_tcon(tlink);
433 	server = tcon->ses->server;
434 
435 	/* could have done a find first instead but this returns more info */
436 	rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
437 				  cifs_sb->local_nls, cifs_remap(cifs_sb));
438 	cifs_dbg(FYI, "%s: query path info: rc = %d\n", __func__, rc);
439 	cifs_put_tlink(tlink);
440 
441 	if (!rc) {
442 		cifs_unix_basic_to_fattr(fattr, &find_data, cifs_sb);
443 	} else if (rc == -EREMOTE) {
444 		cifs_create_junction_fattr(fattr, sb);
445 		rc = 0;
446 	} else {
447 		return rc;
448 	}
449 
450 	if (!*pinode)
451 		cifs_fill_uniqueid(sb, fattr);
452 
453 	/* check for Minshall+French symlinks */
454 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
455 		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
456 		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
457 	}
458 
459 	if (S_ISLNK(fattr->cf_mode) && !fattr->cf_symlink_target) {
460 		if (!server->ops->query_symlink)
461 			return -EOPNOTSUPP;
462 		rc = server->ops->query_symlink(xid, tcon,
463 						cifs_sb, full_path,
464 						&fattr->cf_symlink_target);
465 		cifs_dbg(FYI, "%s: query_symlink: %d\n", __func__, rc);
466 	}
467 	return rc;
468 }
469 
470 int cifs_get_inode_info_unix(struct inode **pinode,
471 			     const unsigned char *full_path,
472 			     struct super_block *sb, unsigned int xid)
473 {
474 	struct cifs_fattr fattr = {};
475 	int rc;
476 
477 	rc = cifs_get_unix_fattr(full_path, sb, &fattr, pinode, xid);
478 	if (rc)
479 		goto out;
480 
481 	rc = update_inode_info(sb, &fattr, pinode);
482 out:
483 	kfree(fattr.cf_symlink_target);
484 	return rc;
485 }
486 #else
487 static inline int cifs_get_unix_fattr(const unsigned char *full_path,
488 				      struct super_block *sb,
489 				      struct cifs_fattr *fattr,
490 				      struct inode **pinode,
491 				      const unsigned int xid)
492 {
493 	return -EOPNOTSUPP;
494 }
495 
496 int cifs_get_inode_info_unix(struct inode **pinode,
497 			     const unsigned char *full_path,
498 			     struct super_block *sb, unsigned int xid)
499 {
500 	return -EOPNOTSUPP;
501 }
502 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
503 
504 static int
505 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
506 	      struct cifs_sb_info *cifs_sb, unsigned int xid)
507 {
508 	int rc;
509 	__u32 oplock;
510 	struct tcon_link *tlink;
511 	struct cifs_tcon *tcon;
512 	struct cifs_fid fid;
513 	struct cifs_open_parms oparms;
514 	struct cifs_io_parms io_parms = {0};
515 	char buf[24];
516 	unsigned int bytes_read;
517 	char *pbuf;
518 	int buf_type = CIFS_NO_BUFFER;
519 
520 	pbuf = buf;
521 
522 	fattr->cf_mode &= ~S_IFMT;
523 
524 	if (fattr->cf_eof == 0) {
525 		fattr->cf_mode |= S_IFIFO;
526 		fattr->cf_dtype = DT_FIFO;
527 		return 0;
528 	} else if (fattr->cf_eof < 8) {
529 		fattr->cf_mode |= S_IFREG;
530 		fattr->cf_dtype = DT_REG;
531 		return -EINVAL;	 /* EOPNOTSUPP? */
532 	}
533 
534 	tlink = cifs_sb_tlink(cifs_sb);
535 	if (IS_ERR(tlink))
536 		return PTR_ERR(tlink);
537 	tcon = tlink_tcon(tlink);
538 
539 	oparms = (struct cifs_open_parms) {
540 		.tcon = tcon,
541 		.cifs_sb = cifs_sb,
542 		.desired_access = GENERIC_READ,
543 		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
544 		.disposition = FILE_OPEN,
545 		.path = path,
546 		.fid = &fid,
547 	};
548 
549 	if (tcon->ses->server->oplocks)
550 		oplock = REQ_OPLOCK;
551 	else
552 		oplock = 0;
553 	rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
554 	if (rc) {
555 		cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
556 		cifs_put_tlink(tlink);
557 		return rc;
558 	}
559 
560 	/* Read header */
561 	io_parms.netfid = fid.netfid;
562 	io_parms.pid = current->tgid;
563 	io_parms.tcon = tcon;
564 	io_parms.offset = 0;
565 	io_parms.length = 24;
566 
567 	rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
568 					&bytes_read, &pbuf, &buf_type);
569 	if ((rc == 0) && (bytes_read >= 8)) {
570 		if (memcmp("IntxBLK", pbuf, 8) == 0) {
571 			cifs_dbg(FYI, "Block device\n");
572 			fattr->cf_mode |= S_IFBLK;
573 			fattr->cf_dtype = DT_BLK;
574 			if (bytes_read == 24) {
575 				/* we have enough to decode dev num */
576 				__u64 mjr; /* major */
577 				__u64 mnr; /* minor */
578 				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
579 				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
580 				fattr->cf_rdev = MKDEV(mjr, mnr);
581 			}
582 		} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
583 			cifs_dbg(FYI, "Char device\n");
584 			fattr->cf_mode |= S_IFCHR;
585 			fattr->cf_dtype = DT_CHR;
586 			if (bytes_read == 24) {
587 				/* we have enough to decode dev num */
588 				__u64 mjr; /* major */
589 				__u64 mnr; /* minor */
590 				mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
591 				mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
592 				fattr->cf_rdev = MKDEV(mjr, mnr);
593 			}
594 		} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
595 			cifs_dbg(FYI, "Symlink\n");
596 			fattr->cf_mode |= S_IFLNK;
597 			fattr->cf_dtype = DT_LNK;
598 		} else if (memcmp("LnxFIFO", pbuf, 8) == 0) {
599 			cifs_dbg(FYI, "FIFO\n");
600 			fattr->cf_mode |= S_IFIFO;
601 			fattr->cf_dtype = DT_FIFO;
602 		} else {
603 			fattr->cf_mode |= S_IFREG; /* file? */
604 			fattr->cf_dtype = DT_REG;
605 			rc = -EOPNOTSUPP;
606 		}
607 	} else {
608 		fattr->cf_mode |= S_IFREG; /* then it is a file */
609 		fattr->cf_dtype = DT_REG;
610 		rc = -EOPNOTSUPP; /* or some unknown SFU type */
611 	}
612 
613 	tcon->ses->server->ops->close(xid, tcon, &fid);
614 	cifs_put_tlink(tlink);
615 	return rc;
616 }
617 
618 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
619 
620 /*
621  * Fetch mode bits as provided by SFU.
622  *
623  * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
624  */
625 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
626 			 struct cifs_sb_info *cifs_sb, unsigned int xid)
627 {
628 #ifdef CONFIG_CIFS_XATTR
629 	ssize_t rc;
630 	char ea_value[4];
631 	__u32 mode;
632 	struct tcon_link *tlink;
633 	struct cifs_tcon *tcon;
634 
635 	tlink = cifs_sb_tlink(cifs_sb);
636 	if (IS_ERR(tlink))
637 		return PTR_ERR(tlink);
638 	tcon = tlink_tcon(tlink);
639 
640 	if (tcon->ses->server->ops->query_all_EAs == NULL) {
641 		cifs_put_tlink(tlink);
642 		return -EOPNOTSUPP;
643 	}
644 
645 	rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
646 			"SETFILEBITS", ea_value, 4 /* size of buf */,
647 			cifs_sb);
648 	cifs_put_tlink(tlink);
649 	if (rc < 0)
650 		return (int)rc;
651 	else if (rc > 3) {
652 		mode = le32_to_cpu(*((__le32 *)ea_value));
653 		fattr->cf_mode &= ~SFBITS_MASK;
654 		cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
655 			 mode, fattr->cf_mode);
656 		fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
657 		cifs_dbg(FYI, "special mode bits 0%o\n", mode);
658 	}
659 
660 	return 0;
661 #else
662 	return -EOPNOTSUPP;
663 #endif
664 }
665 
666 /* Fill a cifs_fattr struct with info from POSIX info struct */
667 static void smb311_posix_info_to_fattr(struct cifs_fattr *fattr,
668 				       struct cifs_open_info_data *data,
669 				       struct super_block *sb)
670 {
671 	struct smb311_posix_qinfo *info = &data->posix_fi;
672 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
673 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
674 
675 	memset(fattr, 0, sizeof(*fattr));
676 
677 	/* no fattr->flags to set */
678 	fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
679 	fattr->cf_uniqueid = le64_to_cpu(info->Inode);
680 
681 	if (info->LastAccessTime)
682 		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
683 	else
684 		ktime_get_coarse_real_ts64(&fattr->cf_atime);
685 
686 	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
687 	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
688 
689 	if (data->adjust_tz) {
690 		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
691 		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
692 	}
693 
694 	/*
695 	 * The srv fs device id is overridden on network mount so setting
696 	 * @fattr->cf_rdev isn't needed here.
697 	 */
698 	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
699 	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
700 	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
701 	fattr->cf_nlink = le32_to_cpu(info->HardLinks);
702 	fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
703 
704 	if (cifs_open_data_reparse(data) &&
705 	    cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
706 		goto out_reparse;
707 
708 	fattr->cf_mode &= ~S_IFMT;
709 	if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
710 		fattr->cf_mode |= S_IFDIR;
711 		fattr->cf_dtype = DT_DIR;
712 	} else { /* file */
713 		fattr->cf_mode |= S_IFREG;
714 		fattr->cf_dtype = DT_REG;
715 	}
716 
717 out_reparse:
718 	if (S_ISLNK(fattr->cf_mode)) {
719 		if (likely(data->symlink_target))
720 			fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
721 		fattr->cf_symlink_target = data->symlink_target;
722 		data->symlink_target = NULL;
723 	}
724 	sid_to_id(cifs_sb, &data->posix_owner, fattr, SIDOWNER);
725 	sid_to_id(cifs_sb, &data->posix_group, fattr, SIDGROUP);
726 
727 	cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d\n",
728 		fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
729 }
730 
731 static void cifs_open_info_to_fattr(struct cifs_fattr *fattr,
732 				    struct cifs_open_info_data *data,
733 				    struct super_block *sb)
734 {
735 	struct smb2_file_all_info *info = &data->fi;
736 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
737 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
738 
739 	memset(fattr, 0, sizeof(*fattr));
740 	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
741 	if (info->DeletePending)
742 		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
743 
744 	if (info->LastAccessTime)
745 		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
746 	else
747 		ktime_get_coarse_real_ts64(&fattr->cf_atime);
748 
749 	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
750 	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
751 
752 	if (data->adjust_tz) {
753 		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
754 		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
755 	}
756 
757 	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
758 	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
759 	fattr->cf_createtime = le64_to_cpu(info->CreationTime);
760 	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
761 	fattr->cf_uid = cifs_sb->ctx->linux_uid;
762 	fattr->cf_gid = cifs_sb->ctx->linux_gid;
763 
764 	fattr->cf_mode = cifs_sb->ctx->file_mode;
765 	if (cifs_open_data_reparse(data) &&
766 	    cifs_reparse_point_to_fattr(cifs_sb, fattr, data))
767 		goto out_reparse;
768 
769 	if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
770 		fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;
771 		fattr->cf_dtype = DT_DIR;
772 		/*
773 		 * Server can return wrong NumberOfLinks value for directories
774 		 * when Unix extensions are disabled - fake it.
775 		 */
776 		if (!tcon->unix_ext)
777 			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
778 	} else {
779 		fattr->cf_mode = S_IFREG | cifs_sb->ctx->file_mode;
780 		fattr->cf_dtype = DT_REG;
781 
782 		/* clear write bits if ATTR_READONLY is set */
783 		if (fattr->cf_cifsattrs & ATTR_READONLY)
784 			fattr->cf_mode &= ~(S_IWUGO);
785 
786 		/*
787 		 * Don't accept zero nlink from non-unix servers unless
788 		 * delete is pending.  Instead mark it as unknown.
789 		 */
790 		if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
791 		    !info->DeletePending) {
792 			cifs_dbg(VFS, "bogus file nlink value %u\n",
793 				 fattr->cf_nlink);
794 			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
795 		}
796 	}
797 
798 out_reparse:
799 	if (S_ISLNK(fattr->cf_mode)) {
800 		if (likely(data->symlink_target))
801 			fattr->cf_eof = strnlen(data->symlink_target, PATH_MAX);
802 		fattr->cf_symlink_target = data->symlink_target;
803 		data->symlink_target = NULL;
804 	}
805 }
806 
807 static int
808 cifs_get_file_info(struct file *filp)
809 {
810 	int rc;
811 	unsigned int xid;
812 	struct cifs_open_info_data data = {};
813 	struct cifs_fattr fattr;
814 	struct inode *inode = file_inode(filp);
815 	struct cifsFileInfo *cfile = filp->private_data;
816 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
817 	struct TCP_Server_Info *server = tcon->ses->server;
818 	struct dentry *dentry = filp->f_path.dentry;
819 	void *page = alloc_dentry_path();
820 	const unsigned char *path;
821 
822 	if (!server->ops->query_file_info) {
823 		free_dentry_path(page);
824 		return -ENOSYS;
825 	}
826 
827 	xid = get_xid();
828 	rc = server->ops->query_file_info(xid, tcon, cfile, &data);
829 	switch (rc) {
830 	case 0:
831 		/* TODO: add support to query reparse tag */
832 		data.adjust_tz = false;
833 		if (data.symlink_target) {
834 			data.symlink = true;
835 			data.reparse.tag = IO_REPARSE_TAG_SYMLINK;
836 		}
837 		path = build_path_from_dentry(dentry, page);
838 		if (IS_ERR(path)) {
839 			rc = PTR_ERR(path);
840 			goto cgfi_exit;
841 		}
842 		cifs_open_info_to_fattr(&fattr, &data, inode->i_sb);
843 		if (fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
844 			cifs_mark_open_handles_for_deleted_file(inode, path);
845 		break;
846 	case -EREMOTE:
847 		cifs_create_junction_fattr(&fattr, inode->i_sb);
848 		break;
849 	case -EOPNOTSUPP:
850 	case -EINVAL:
851 		/*
852 		 * FIXME: legacy server -- fall back to path-based call?
853 		 * for now, just skip revalidating and mark inode for
854 		 * immediate reval.
855 		 */
856 		rc = 0;
857 		CIFS_I(inode)->time = 0;
858 		goto cgfi_exit;
859 	default:
860 		goto cgfi_exit;
861 	}
862 
863 	/*
864 	 * don't bother with SFU junk here -- just mark inode as needing
865 	 * revalidation.
866 	 */
867 	fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
868 	fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
869 	/* if filetype is different, return error */
870 	rc = cifs_fattr_to_inode(inode, &fattr, false);
871 cgfi_exit:
872 	cifs_free_open_info(&data);
873 	free_dentry_path(page);
874 	free_xid(xid);
875 	return rc;
876 }
877 
878 /* Simple function to return a 64 bit hash of string.  Rarely called */
879 static __u64 simple_hashstr(const char *str)
880 {
881 	const __u64 hash_mult =  1125899906842597ULL; /* a big enough prime */
882 	__u64 hash = 0;
883 
884 	while (*str)
885 		hash = (hash + (__u64) *str++) * hash_mult;
886 
887 	return hash;
888 }
889 
890 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
891 /**
892  * cifs_backup_query_path_info - SMB1 fallback code to get ino
893  *
894  * Fallback code to get file metadata when we don't have access to
895  * full_path (EACCES) and have backup creds.
896  *
897  * @xid:	transaction id used to identify original request in logs
898  * @tcon:	information about the server share we have mounted
899  * @sb:	the superblock stores info such as disk space available
900  * @full_path:	name of the file we are getting the metadata for
901  * @resp_buf:	will be set to cifs resp buf and needs to be freed with
902  * 		cifs_buf_release() when done with @data
903  * @data:	will be set to search info result buffer
904  */
905 static int
906 cifs_backup_query_path_info(int xid,
907 			    struct cifs_tcon *tcon,
908 			    struct super_block *sb,
909 			    const char *full_path,
910 			    void **resp_buf,
911 			    FILE_ALL_INFO **data)
912 {
913 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
914 	struct cifs_search_info info = {0};
915 	u16 flags;
916 	int rc;
917 
918 	*resp_buf = NULL;
919 	info.endOfSearch = false;
920 	if (tcon->unix_ext)
921 		info.info_level = SMB_FIND_FILE_UNIX;
922 	else if ((tcon->ses->capabilities &
923 		  tcon->ses->server->vals->cap_nt_find) == 0)
924 		info.info_level = SMB_FIND_FILE_INFO_STANDARD;
925 	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
926 		info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
927 	else /* no srvino useful for fallback to some netapp */
928 		info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
929 
930 	flags = CIFS_SEARCH_CLOSE_ALWAYS |
931 		CIFS_SEARCH_CLOSE_AT_END |
932 		CIFS_SEARCH_BACKUP_SEARCH;
933 
934 	rc = CIFSFindFirst(xid, tcon, full_path,
935 			   cifs_sb, NULL, flags, &info, false);
936 	if (rc)
937 		return rc;
938 
939 	*resp_buf = (void *)info.ntwrk_buf_start;
940 	*data = (FILE_ALL_INFO *)info.srch_entries_start;
941 	return 0;
942 }
943 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
944 
945 static void cifs_set_fattr_ino(int xid, struct cifs_tcon *tcon, struct super_block *sb,
946 			       struct inode **inode, const char *full_path,
947 			       struct cifs_open_info_data *data, struct cifs_fattr *fattr)
948 {
949 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
950 	struct TCP_Server_Info *server = tcon->ses->server;
951 	int rc;
952 
953 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
954 		if (*inode)
955 			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
956 		else
957 			fattr->cf_uniqueid = iunique(sb, ROOT_I);
958 		return;
959 	}
960 
961 	/*
962 	 * If we have an inode pass a NULL tcon to ensure we don't
963 	 * make a round trip to the server. This only works for SMB2+.
964 	 */
965 	rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,
966 				       &fattr->cf_uniqueid, data);
967 	if (rc) {
968 		/*
969 		 * If that fails reuse existing ino or generate one
970 		 * and disable server ones
971 		 */
972 		if (*inode)
973 			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
974 		else {
975 			fattr->cf_uniqueid = iunique(sb, ROOT_I);
976 			cifs_autodisable_serverino(cifs_sb);
977 		}
978 		return;
979 	}
980 
981 	/* If no errors, check for zero root inode (invalid) */
982 	if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
983 		cifs_dbg(FYI, "Invalid (0) inodenum\n");
984 		if (*inode) {
985 			/* reuse */
986 			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
987 		} else {
988 			/* make an ino by hashing the UNC */
989 			fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
990 			fattr->cf_uniqueid = simple_hashstr(tcon->tree_name);
991 		}
992 	}
993 }
994 
995 static inline bool is_inode_cache_good(struct inode *ino)
996 {
997 	return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
998 }
999 
1000 static int reparse_info_to_fattr(struct cifs_open_info_data *data,
1001 				 struct super_block *sb,
1002 				 const unsigned int xid,
1003 				 struct cifs_tcon *tcon,
1004 				 const char *full_path,
1005 				 struct cifs_fattr *fattr)
1006 {
1007 	struct TCP_Server_Info *server = tcon->ses->server;
1008 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1009 	struct kvec rsp_iov, *iov = NULL;
1010 	int rsp_buftype = CIFS_NO_BUFFER;
1011 	u32 tag = data->reparse.tag;
1012 	int rc = 0;
1013 
1014 	if (!tag && server->ops->query_reparse_point) {
1015 		rc = server->ops->query_reparse_point(xid, tcon, cifs_sb,
1016 						      full_path, &tag,
1017 						      &rsp_iov, &rsp_buftype);
1018 		if (!rc)
1019 			iov = &rsp_iov;
1020 	} else if (data->reparse.io.buftype != CIFS_NO_BUFFER &&
1021 		   data->reparse.io.iov.iov_base) {
1022 		iov = &data->reparse.io.iov;
1023 	}
1024 
1025 	rc = -EOPNOTSUPP;
1026 	switch ((data->reparse.tag = tag)) {
1027 	case 0: /* SMB1 symlink */
1028 		if (server->ops->query_symlink) {
1029 			rc = server->ops->query_symlink(xid, tcon,
1030 							cifs_sb, full_path,
1031 							&data->symlink_target);
1032 		}
1033 		break;
1034 	case IO_REPARSE_TAG_MOUNT_POINT:
1035 		cifs_create_junction_fattr(fattr, sb);
1036 		rc = 0;
1037 		goto out;
1038 	default:
1039 		/* Check for cached reparse point data */
1040 		if (data->symlink_target || data->reparse.buf) {
1041 			rc = 0;
1042 		} else if (iov && server->ops->parse_reparse_point) {
1043 			rc = server->ops->parse_reparse_point(cifs_sb,
1044 							      iov, data);
1045 		}
1046 		break;
1047 	}
1048 
1049 	if (tcon->posix_extensions)
1050 		smb311_posix_info_to_fattr(fattr, data, sb);
1051 	else
1052 		cifs_open_info_to_fattr(fattr, data, sb);
1053 out:
1054 	fattr->cf_cifstag = data->reparse.tag;
1055 	free_rsp_buf(rsp_buftype, rsp_iov.iov_base);
1056 	return rc;
1057 }
1058 
1059 static int cifs_get_fattr(struct cifs_open_info_data *data,
1060 			  struct super_block *sb, int xid,
1061 			  const struct cifs_fid *fid,
1062 			  struct cifs_fattr *fattr,
1063 			  struct inode **inode,
1064 			  const char *full_path)
1065 {
1066 	struct cifs_open_info_data tmp_data = {};
1067 	struct cifs_tcon *tcon;
1068 	struct TCP_Server_Info *server;
1069 	struct tcon_link *tlink;
1070 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1071 	void *smb1_backup_rsp_buf = NULL;
1072 	int rc = 0;
1073 	int tmprc = 0;
1074 
1075 	tlink = cifs_sb_tlink(cifs_sb);
1076 	if (IS_ERR(tlink))
1077 		return PTR_ERR(tlink);
1078 	tcon = tlink_tcon(tlink);
1079 	server = tcon->ses->server;
1080 
1081 	/*
1082 	 * 1. Fetch file metadata if not provided (data)
1083 	 */
1084 
1085 	if (!data) {
1086 		rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1087 						  full_path, &tmp_data);
1088 		data = &tmp_data;
1089 	}
1090 
1091 	/*
1092 	 * 2. Convert it to internal cifs metadata (fattr)
1093 	 */
1094 
1095 	switch (rc) {
1096 	case 0:
1097 		/*
1098 		 * If the file is a reparse point, it is more complicated
1099 		 * since we have to check if its reparse tag matches a known
1100 		 * special file type e.g. symlink or fifo or char etc.
1101 		 */
1102 		if (cifs_open_data_reparse(data)) {
1103 			rc = reparse_info_to_fattr(data, sb, xid, tcon,
1104 						   full_path, fattr);
1105 		} else {
1106 			cifs_open_info_to_fattr(fattr, data, sb);
1107 		}
1108 		if (!rc && *inode &&
1109 		    (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING))
1110 			cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1111 		break;
1112 	case -EREMOTE:
1113 		/* DFS link, no metadata available on this server */
1114 		cifs_create_junction_fattr(fattr, sb);
1115 		rc = 0;
1116 		break;
1117 	case -EACCES:
1118 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1119 		/*
1120 		 * perm errors, try again with backup flags if possible
1121 		 *
1122 		 * For SMB2 and later the backup intent flag
1123 		 * is already sent if needed on open and there
1124 		 * is no path based FindFirst operation to use
1125 		 * to retry with
1126 		 */
1127 		if (backup_cred(cifs_sb) && is_smb1_server(server)) {
1128 			/* for easier reading */
1129 			FILE_ALL_INFO *fi;
1130 			FILE_DIRECTORY_INFO *fdi;
1131 			SEARCH_ID_FULL_DIR_INFO *si;
1132 
1133 			rc = cifs_backup_query_path_info(xid, tcon, sb,
1134 							 full_path,
1135 							 &smb1_backup_rsp_buf,
1136 							 &fi);
1137 			if (rc)
1138 				goto out;
1139 
1140 			move_cifs_info_to_smb2(&data->fi, fi);
1141 			fdi = (FILE_DIRECTORY_INFO *)fi;
1142 			si = (SEARCH_ID_FULL_DIR_INFO *)fi;
1143 
1144 			cifs_dir_info_to_fattr(fattr, fdi, cifs_sb);
1145 			fattr->cf_uniqueid = le64_to_cpu(si->UniqueId);
1146 			/* uniqueid set, skip get inum step */
1147 			goto handle_mnt_opt;
1148 		} else {
1149 			/* nothing we can do, bail out */
1150 			goto out;
1151 		}
1152 #else
1153 		goto out;
1154 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1155 		break;
1156 	default:
1157 		cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1158 		goto out;
1159 	}
1160 
1161 	/*
1162 	 * 3. Get or update inode number (fattr->cf_uniqueid)
1163 	 */
1164 
1165 	cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, fattr);
1166 
1167 	/*
1168 	 * 4. Tweak fattr based on mount options
1169 	 */
1170 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1171 handle_mnt_opt:
1172 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1173 	/* query for SFU type info if supported and needed */
1174 	if ((fattr->cf_cifsattrs & ATTR_SYSTEM) &&
1175 	    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
1176 		tmprc = cifs_sfu_type(fattr, full_path, cifs_sb, xid);
1177 		if (tmprc)
1178 			cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
1179 	}
1180 
1181 	/* fill in 0777 bits from ACL */
1182 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
1183 		rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1184 				       true, full_path, fid);
1185 		if (rc == -EREMOTE)
1186 			rc = 0;
1187 		if (rc) {
1188 			cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
1189 				 __func__, rc);
1190 			goto out;
1191 		}
1192 	} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
1193 		rc = cifs_acl_to_fattr(cifs_sb, fattr, *inode,
1194 				       false, full_path, fid);
1195 		if (rc == -EREMOTE)
1196 			rc = 0;
1197 		if (rc) {
1198 			cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
1199 				 __func__, rc);
1200 			goto out;
1201 		}
1202 	}
1203 
1204 	/* fill in remaining high mode bits e.g. SUID, VTX */
1205 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
1206 		cifs_sfu_mode(fattr, full_path, cifs_sb, xid);
1207 
1208 	/* check for Minshall+French symlinks */
1209 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1210 		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1211 		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1212 	}
1213 
1214 out:
1215 	cifs_buf_release(smb1_backup_rsp_buf);
1216 	cifs_put_tlink(tlink);
1217 	cifs_free_open_info(&tmp_data);
1218 	return rc;
1219 }
1220 
1221 int cifs_get_inode_info(struct inode **inode,
1222 			const char *full_path,
1223 			struct cifs_open_info_data *data,
1224 			struct super_block *sb, int xid,
1225 			const struct cifs_fid *fid)
1226 {
1227 	struct cifs_fattr fattr = {};
1228 	int rc;
1229 
1230 	if (is_inode_cache_good(*inode)) {
1231 		cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1232 		return 0;
1233 	}
1234 
1235 	rc = cifs_get_fattr(data, sb, xid, fid, &fattr, inode, full_path);
1236 	if (rc)
1237 		goto out;
1238 
1239 	rc = update_inode_info(sb, &fattr, inode);
1240 out:
1241 	kfree(fattr.cf_symlink_target);
1242 	return rc;
1243 }
1244 
1245 static int smb311_posix_get_fattr(struct cifs_open_info_data *data,
1246 				  struct cifs_fattr *fattr,
1247 				  const char *full_path,
1248 				  struct super_block *sb,
1249 				  const unsigned int xid)
1250 {
1251 	struct cifs_open_info_data tmp_data = {};
1252 	struct TCP_Server_Info *server;
1253 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1254 	struct cifs_tcon *tcon;
1255 	struct tcon_link *tlink;
1256 	int tmprc;
1257 	int rc = 0;
1258 
1259 	tlink = cifs_sb_tlink(cifs_sb);
1260 	if (IS_ERR(tlink))
1261 		return PTR_ERR(tlink);
1262 	tcon = tlink_tcon(tlink);
1263 	server = tcon->ses->server;
1264 
1265 	/*
1266 	 * 1. Fetch file metadata if not provided (data)
1267 	 */
1268 	if (!data) {
1269 		rc = server->ops->query_path_info(xid, tcon, cifs_sb,
1270 						  full_path, &tmp_data);
1271 		data = &tmp_data;
1272 	}
1273 
1274 	/*
1275 	 * 2. Convert it to internal cifs metadata (fattr)
1276 	 */
1277 
1278 	switch (rc) {
1279 	case 0:
1280 		if (cifs_open_data_reparse(data)) {
1281 			rc = reparse_info_to_fattr(data, sb, xid, tcon,
1282 						   full_path, fattr);
1283 		} else {
1284 			smb311_posix_info_to_fattr(fattr, data, sb);
1285 		}
1286 		break;
1287 	case -EREMOTE:
1288 		/* DFS link, no metadata available on this server */
1289 		cifs_create_junction_fattr(fattr, sb);
1290 		rc = 0;
1291 		break;
1292 	case -EACCES:
1293 		/*
1294 		 * For SMB2 and later the backup intent flag
1295 		 * is already sent if needed on open and there
1296 		 * is no path based FindFirst operation to use
1297 		 * to retry with so nothing we can do, bail out
1298 		 */
1299 		goto out;
1300 	default:
1301 		cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1302 		goto out;
1303 	}
1304 
1305 	/*
1306 	 * 3. Tweak fattr based on mount options
1307 	 */
1308 	/* check for Minshall+French symlinks */
1309 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1310 		tmprc = check_mf_symlink(xid, tcon, cifs_sb, fattr, full_path);
1311 		cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1312 	}
1313 
1314 out:
1315 	cifs_put_tlink(tlink);
1316 	cifs_free_open_info(data);
1317 	return rc;
1318 }
1319 
1320 int smb311_posix_get_inode_info(struct inode **inode,
1321 				const char *full_path,
1322 				struct cifs_open_info_data *data,
1323 				struct super_block *sb,
1324 				const unsigned int xid)
1325 {
1326 	struct cifs_fattr fattr = {};
1327 	int rc;
1328 
1329 	if (is_inode_cache_good(*inode)) {
1330 		cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1331 		return 0;
1332 	}
1333 
1334 	rc = smb311_posix_get_fattr(data, &fattr, full_path, sb, xid);
1335 	if (rc)
1336 		goto out;
1337 
1338 	rc = update_inode_info(sb, &fattr, inode);
1339 	if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1340 		cifs_mark_open_handles_for_deleted_file(*inode, full_path);
1341 out:
1342 	kfree(fattr.cf_symlink_target);
1343 	return rc;
1344 }
1345 
1346 static const struct inode_operations cifs_ipc_inode_ops = {
1347 	.lookup = cifs_lookup,
1348 };
1349 
1350 static int
1351 cifs_find_inode(struct inode *inode, void *opaque)
1352 {
1353 	struct cifs_fattr *fattr = opaque;
1354 
1355 	/* [!] The compared values must be the same in struct cifs_fscache_inode_key. */
1356 
1357 	/* don't match inode with different uniqueid */
1358 	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1359 		return 0;
1360 
1361 	/* use createtime like an i_generation field */
1362 	if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1363 		return 0;
1364 
1365 	/* don't match inode of different type */
1366 	if (inode_wrong_type(inode, fattr->cf_mode))
1367 		return 0;
1368 
1369 	/* if it's not a directory or has no dentries, then flag it */
1370 	if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1371 		fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1372 
1373 	return 1;
1374 }
1375 
1376 static int
1377 cifs_init_inode(struct inode *inode, void *opaque)
1378 {
1379 	struct cifs_fattr *fattr = opaque;
1380 
1381 	CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1382 	CIFS_I(inode)->createtime = fattr->cf_createtime;
1383 	return 0;
1384 }
1385 
1386 /*
1387  * walk dentry list for an inode and report whether it has aliases that
1388  * are hashed. We use this to determine if a directory inode can actually
1389  * be used.
1390  */
1391 static bool
1392 inode_has_hashed_dentries(struct inode *inode)
1393 {
1394 	struct dentry *dentry;
1395 
1396 	spin_lock(&inode->i_lock);
1397 	hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1398 		if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1399 			spin_unlock(&inode->i_lock);
1400 			return true;
1401 		}
1402 	}
1403 	spin_unlock(&inode->i_lock);
1404 	return false;
1405 }
1406 
1407 /* Given fattrs, get a corresponding inode */
1408 struct inode *
1409 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1410 {
1411 	unsigned long hash;
1412 	struct inode *inode;
1413 
1414 retry_iget5_locked:
1415 	cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1416 
1417 	/* hash down to 32-bits on 32-bit arch */
1418 	hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1419 
1420 	inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1421 	if (inode) {
1422 		/* was there a potentially problematic inode collision? */
1423 		if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1424 			fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1425 
1426 			if (inode_has_hashed_dentries(inode)) {
1427 				cifs_autodisable_serverino(CIFS_SB(sb));
1428 				iput(inode);
1429 				fattr->cf_uniqueid = iunique(sb, ROOT_I);
1430 				goto retry_iget5_locked;
1431 			}
1432 		}
1433 
1434 		/* can't fail - see cifs_find_inode() */
1435 		cifs_fattr_to_inode(inode, fattr, false);
1436 		if (sb->s_flags & SB_NOATIME)
1437 			inode->i_flags |= S_NOATIME | S_NOCMTIME;
1438 		if (inode->i_state & I_NEW) {
1439 			inode->i_ino = hash;
1440 			cifs_fscache_get_inode_cookie(inode);
1441 			unlock_new_inode(inode);
1442 		}
1443 	}
1444 
1445 	return inode;
1446 }
1447 
1448 /* gets root inode */
1449 struct inode *cifs_root_iget(struct super_block *sb)
1450 {
1451 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1452 	struct cifs_fattr fattr = {};
1453 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1454 	struct inode *inode = NULL;
1455 	unsigned int xid;
1456 	char *path = NULL;
1457 	int len;
1458 	int rc;
1459 
1460 	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1461 	    && cifs_sb->prepath) {
1462 		len = strlen(cifs_sb->prepath);
1463 		path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1464 		if (path == NULL)
1465 			return ERR_PTR(-ENOMEM);
1466 		path[0] = '/';
1467 		memcpy(path+1, cifs_sb->prepath, len);
1468 	} else {
1469 		path = kstrdup("", GFP_KERNEL);
1470 		if (path == NULL)
1471 			return ERR_PTR(-ENOMEM);
1472 	}
1473 
1474 	xid = get_xid();
1475 	if (tcon->unix_ext) {
1476 		rc = cifs_get_unix_fattr(path, sb, &fattr, &inode, xid);
1477 		/* some servers mistakenly claim POSIX support */
1478 		if (rc != -EOPNOTSUPP)
1479 			goto iget_root;
1480 		cifs_dbg(VFS, "server does not support POSIX extensions\n");
1481 		tcon->unix_ext = false;
1482 	}
1483 
1484 	convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1485 	if (tcon->posix_extensions)
1486 		rc = smb311_posix_get_fattr(NULL, &fattr, path, sb, xid);
1487 	else
1488 		rc = cifs_get_fattr(NULL, sb, xid, NULL, &fattr, &inode, path);
1489 
1490 iget_root:
1491 	if (!rc) {
1492 		if (fattr.cf_flags & CIFS_FATTR_JUNCTION) {
1493 			fattr.cf_flags &= ~CIFS_FATTR_JUNCTION;
1494 			cifs_autodisable_serverino(cifs_sb);
1495 		}
1496 		inode = cifs_iget(sb, &fattr);
1497 	}
1498 
1499 	if (!inode) {
1500 		inode = ERR_PTR(rc);
1501 		goto out;
1502 	}
1503 
1504 	if (!rc && fattr.cf_flags & CIFS_FATTR_DELETE_PENDING)
1505 		cifs_mark_open_handles_for_deleted_file(inode, path);
1506 
1507 	if (rc && tcon->pipe) {
1508 		cifs_dbg(FYI, "ipc connection - fake read inode\n");
1509 		spin_lock(&inode->i_lock);
1510 		inode->i_mode |= S_IFDIR;
1511 		set_nlink(inode, 2);
1512 		inode->i_op = &cifs_ipc_inode_ops;
1513 		inode->i_fop = &simple_dir_operations;
1514 		inode->i_uid = cifs_sb->ctx->linux_uid;
1515 		inode->i_gid = cifs_sb->ctx->linux_gid;
1516 		spin_unlock(&inode->i_lock);
1517 	} else if (rc) {
1518 		iget_failed(inode);
1519 		inode = ERR_PTR(rc);
1520 	}
1521 
1522 out:
1523 	kfree(path);
1524 	free_xid(xid);
1525 	kfree(fattr.cf_symlink_target);
1526 	return inode;
1527 }
1528 
1529 int
1530 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1531 		   const char *full_path, __u32 dosattr)
1532 {
1533 	bool set_time = false;
1534 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1535 	struct TCP_Server_Info *server;
1536 	FILE_BASIC_INFO	info_buf;
1537 
1538 	if (attrs == NULL)
1539 		return -EINVAL;
1540 
1541 	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1542 	if (!server->ops->set_file_info)
1543 		return -ENOSYS;
1544 
1545 	info_buf.Pad = 0;
1546 
1547 	if (attrs->ia_valid & ATTR_ATIME) {
1548 		set_time = true;
1549 		info_buf.LastAccessTime =
1550 			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1551 	} else
1552 		info_buf.LastAccessTime = 0;
1553 
1554 	if (attrs->ia_valid & ATTR_MTIME) {
1555 		set_time = true;
1556 		info_buf.LastWriteTime =
1557 		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1558 	} else
1559 		info_buf.LastWriteTime = 0;
1560 
1561 	/*
1562 	 * Samba throws this field away, but windows may actually use it.
1563 	 * Do not set ctime unless other time stamps are changed explicitly
1564 	 * (i.e. by utimes()) since we would then have a mix of client and
1565 	 * server times.
1566 	 */
1567 	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1568 		cifs_dbg(FYI, "CIFS - CTIME changed\n");
1569 		info_buf.ChangeTime =
1570 		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1571 	} else
1572 		info_buf.ChangeTime = 0;
1573 
1574 	info_buf.CreationTime = 0;	/* don't change */
1575 	info_buf.Attributes = cpu_to_le32(dosattr);
1576 
1577 	return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1578 }
1579 
1580 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1581 /*
1582  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1583  * and rename it to a random name that hopefully won't conflict with
1584  * anything else.
1585  */
1586 int
1587 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1588 			   const unsigned int xid)
1589 {
1590 	int oplock = 0;
1591 	int rc;
1592 	struct cifs_fid fid;
1593 	struct cifs_open_parms oparms;
1594 	struct inode *inode = d_inode(dentry);
1595 	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1596 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1597 	struct tcon_link *tlink;
1598 	struct cifs_tcon *tcon;
1599 	__u32 dosattr, origattr;
1600 	FILE_BASIC_INFO *info_buf = NULL;
1601 
1602 	tlink = cifs_sb_tlink(cifs_sb);
1603 	if (IS_ERR(tlink))
1604 		return PTR_ERR(tlink);
1605 	tcon = tlink_tcon(tlink);
1606 
1607 	/*
1608 	 * We cannot rename the file if the server doesn't support
1609 	 * CAP_INFOLEVEL_PASSTHRU
1610 	 */
1611 	if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1612 		rc = -EBUSY;
1613 		goto out;
1614 	}
1615 
1616 	oparms = (struct cifs_open_parms) {
1617 		.tcon = tcon,
1618 		.cifs_sb = cifs_sb,
1619 		.desired_access = DELETE | FILE_WRITE_ATTRIBUTES,
1620 		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
1621 		.disposition = FILE_OPEN,
1622 		.path = full_path,
1623 		.fid = &fid,
1624 	};
1625 
1626 	rc = CIFS_open(xid, &oparms, &oplock, NULL);
1627 	if (rc != 0)
1628 		goto out;
1629 
1630 	origattr = cifsInode->cifsAttrs;
1631 	if (origattr == 0)
1632 		origattr |= ATTR_NORMAL;
1633 
1634 	dosattr = origattr & ~ATTR_READONLY;
1635 	if (dosattr == 0)
1636 		dosattr |= ATTR_NORMAL;
1637 	dosattr |= ATTR_HIDDEN;
1638 
1639 	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1640 	if (dosattr != origattr) {
1641 		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1642 		if (info_buf == NULL) {
1643 			rc = -ENOMEM;
1644 			goto out_close;
1645 		}
1646 		info_buf->Attributes = cpu_to_le32(dosattr);
1647 		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1648 					current->tgid);
1649 		/* although we would like to mark the file hidden
1650  		   if that fails we will still try to rename it */
1651 		if (!rc)
1652 			cifsInode->cifsAttrs = dosattr;
1653 		else
1654 			dosattr = origattr; /* since not able to change them */
1655 	}
1656 
1657 	/* rename the file */
1658 	rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1659 				   cifs_sb->local_nls,
1660 				   cifs_remap(cifs_sb));
1661 	if (rc != 0) {
1662 		rc = -EBUSY;
1663 		goto undo_setattr;
1664 	}
1665 
1666 	/* try to set DELETE_ON_CLOSE */
1667 	if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1668 		rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1669 					       current->tgid);
1670 		/*
1671 		 * some samba versions return -ENOENT when we try to set the
1672 		 * file disposition here. Likely a samba bug, but work around
1673 		 * it for now. This means that some cifsXXX files may hang
1674 		 * around after they shouldn't.
1675 		 *
1676 		 * BB: remove this hack after more servers have the fix
1677 		 */
1678 		if (rc == -ENOENT)
1679 			rc = 0;
1680 		else if (rc != 0) {
1681 			rc = -EBUSY;
1682 			goto undo_rename;
1683 		}
1684 		set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1685 	}
1686 
1687 out_close:
1688 	CIFSSMBClose(xid, tcon, fid.netfid);
1689 out:
1690 	kfree(info_buf);
1691 	cifs_put_tlink(tlink);
1692 	return rc;
1693 
1694 	/*
1695 	 * reset everything back to the original state. Don't bother
1696 	 * dealing with errors here since we can't do anything about
1697 	 * them anyway.
1698 	 */
1699 undo_rename:
1700 	CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1701 				cifs_sb->local_nls, cifs_remap(cifs_sb));
1702 undo_setattr:
1703 	if (dosattr != origattr) {
1704 		info_buf->Attributes = cpu_to_le32(origattr);
1705 		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1706 					current->tgid))
1707 			cifsInode->cifsAttrs = origattr;
1708 	}
1709 
1710 	goto out_close;
1711 }
1712 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1713 
1714 /* copied from fs/nfs/dir.c with small changes */
1715 static void
1716 cifs_drop_nlink(struct inode *inode)
1717 {
1718 	spin_lock(&inode->i_lock);
1719 	if (inode->i_nlink > 0)
1720 		drop_nlink(inode);
1721 	spin_unlock(&inode->i_lock);
1722 }
1723 
1724 /*
1725  * If d_inode(dentry) is null (usually meaning the cached dentry
1726  * is a negative dentry) then we would attempt a standard SMB delete, but
1727  * if that fails we can not attempt the fall back mechanisms on EACCES
1728  * but will return the EACCES to the caller. Note that the VFS does not call
1729  * unlink on negative dentries currently.
1730  */
1731 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1732 {
1733 	int rc = 0;
1734 	unsigned int xid;
1735 	const char *full_path;
1736 	void *page;
1737 	struct inode *inode = d_inode(dentry);
1738 	struct cifsInodeInfo *cifs_inode;
1739 	struct super_block *sb = dir->i_sb;
1740 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1741 	struct tcon_link *tlink;
1742 	struct cifs_tcon *tcon;
1743 	struct TCP_Server_Info *server;
1744 	struct iattr *attrs = NULL;
1745 	__u32 dosattr = 0, origattr = 0;
1746 
1747 	cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1748 
1749 	if (unlikely(cifs_forced_shutdown(cifs_sb)))
1750 		return -EIO;
1751 
1752 	tlink = cifs_sb_tlink(cifs_sb);
1753 	if (IS_ERR(tlink))
1754 		return PTR_ERR(tlink);
1755 	tcon = tlink_tcon(tlink);
1756 	server = tcon->ses->server;
1757 
1758 	xid = get_xid();
1759 	page = alloc_dentry_path();
1760 
1761 	if (tcon->nodelete) {
1762 		rc = -EACCES;
1763 		goto unlink_out;
1764 	}
1765 
1766 	/* Unlink can be called from rename so we can not take the
1767 	 * sb->s_vfs_rename_mutex here */
1768 	full_path = build_path_from_dentry(dentry, page);
1769 	if (IS_ERR(full_path)) {
1770 		rc = PTR_ERR(full_path);
1771 		goto unlink_out;
1772 	}
1773 
1774 	cifs_close_deferred_file_under_dentry(tcon, full_path);
1775 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1776 	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1777 				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1778 		rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1779 			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1780 			cifs_remap(cifs_sb));
1781 		cifs_dbg(FYI, "posix del rc %d\n", rc);
1782 		if ((rc == 0) || (rc == -ENOENT))
1783 			goto psx_del_no_retry;
1784 	}
1785 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1786 
1787 retry_std_delete:
1788 	if (!server->ops->unlink) {
1789 		rc = -ENOSYS;
1790 		goto psx_del_no_retry;
1791 	}
1792 
1793 	rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry);
1794 
1795 psx_del_no_retry:
1796 	if (!rc) {
1797 		if (inode) {
1798 			cifs_mark_open_handles_for_deleted_file(inode, full_path);
1799 			cifs_drop_nlink(inode);
1800 		}
1801 	} else if (rc == -ENOENT) {
1802 		d_drop(dentry);
1803 	} else if (rc == -EBUSY) {
1804 		if (server->ops->rename_pending_delete) {
1805 			rc = server->ops->rename_pending_delete(full_path,
1806 								dentry, xid);
1807 			if (rc == 0) {
1808 				cifs_mark_open_handles_for_deleted_file(inode, full_path);
1809 				cifs_drop_nlink(inode);
1810 			}
1811 		}
1812 	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1813 		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1814 		if (attrs == NULL) {
1815 			rc = -ENOMEM;
1816 			goto out_reval;
1817 		}
1818 
1819 		/* try to reset dos attributes */
1820 		cifs_inode = CIFS_I(inode);
1821 		origattr = cifs_inode->cifsAttrs;
1822 		if (origattr == 0)
1823 			origattr |= ATTR_NORMAL;
1824 		dosattr = origattr & ~ATTR_READONLY;
1825 		if (dosattr == 0)
1826 			dosattr |= ATTR_NORMAL;
1827 		dosattr |= ATTR_HIDDEN;
1828 
1829 		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1830 		if (rc != 0)
1831 			goto out_reval;
1832 
1833 		goto retry_std_delete;
1834 	}
1835 
1836 	/* undo the setattr if we errored out and it's needed */
1837 	if (rc != 0 && dosattr != 0)
1838 		cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1839 
1840 out_reval:
1841 	if (inode) {
1842 		cifs_inode = CIFS_I(inode);
1843 		cifs_inode->time = 0;	/* will force revalidate to get info
1844 					   when needed */
1845 		inode_set_ctime_current(inode);
1846 	}
1847 	inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
1848 	cifs_inode = CIFS_I(dir);
1849 	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */
1850 unlink_out:
1851 	free_dentry_path(page);
1852 	kfree(attrs);
1853 	free_xid(xid);
1854 	cifs_put_tlink(tlink);
1855 	return rc;
1856 }
1857 
1858 static int
1859 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1860 		 const char *full_path, struct cifs_sb_info *cifs_sb,
1861 		 struct cifs_tcon *tcon, const unsigned int xid)
1862 {
1863 	int rc = 0;
1864 	struct inode *inode = NULL;
1865 
1866 	if (tcon->posix_extensions) {
1867 		rc = smb311_posix_get_inode_info(&inode, full_path,
1868 						 NULL, parent->i_sb, xid);
1869 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1870 	} else if (tcon->unix_ext) {
1871 		rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1872 					      xid);
1873 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1874 	} else {
1875 		rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1876 					 xid, NULL);
1877 	}
1878 
1879 	if (rc)
1880 		return rc;
1881 
1882 	if (!S_ISDIR(inode->i_mode)) {
1883 		/*
1884 		 * mkdir succeeded, but another client has managed to remove the
1885 		 * sucker and replace it with non-directory.  Return success,
1886 		 * but don't leave the child in dcache.
1887 		 */
1888 		 iput(inode);
1889 		 d_drop(dentry);
1890 		 return 0;
1891 	}
1892 	/*
1893 	 * setting nlink not necessary except in cases where we failed to get it
1894 	 * from the server or was set bogus. Also, since this is a brand new
1895 	 * inode, no need to grab the i_lock before setting the i_nlink.
1896 	 */
1897 	if (inode->i_nlink < 2)
1898 		set_nlink(inode, 2);
1899 	mode &= ~current_umask();
1900 	/* must turn on setgid bit if parent dir has it */
1901 	if (parent->i_mode & S_ISGID)
1902 		mode |= S_ISGID;
1903 
1904 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1905 	if (tcon->unix_ext) {
1906 		struct cifs_unix_set_info_args args = {
1907 			.mode	= mode,
1908 			.ctime	= NO_CHANGE_64,
1909 			.atime	= NO_CHANGE_64,
1910 			.mtime	= NO_CHANGE_64,
1911 			.device	= 0,
1912 		};
1913 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1914 			args.uid = current_fsuid();
1915 			if (parent->i_mode & S_ISGID)
1916 				args.gid = parent->i_gid;
1917 			else
1918 				args.gid = current_fsgid();
1919 		} else {
1920 			args.uid = INVALID_UID; /* no change */
1921 			args.gid = INVALID_GID; /* no change */
1922 		}
1923 		CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1924 				       cifs_sb->local_nls,
1925 				       cifs_remap(cifs_sb));
1926 	} else {
1927 #else
1928 	{
1929 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1930 		struct TCP_Server_Info *server = tcon->ses->server;
1931 		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1932 		    (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1933 			server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1934 						   tcon, xid);
1935 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1936 			inode->i_mode = (mode | S_IFDIR);
1937 
1938 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1939 			inode->i_uid = current_fsuid();
1940 			if (inode->i_mode & S_ISGID)
1941 				inode->i_gid = parent->i_gid;
1942 			else
1943 				inode->i_gid = current_fsgid();
1944 		}
1945 	}
1946 	d_instantiate(dentry, inode);
1947 	return 0;
1948 }
1949 
1950 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1951 static int
1952 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1953 		 const char *full_path, struct cifs_sb_info *cifs_sb,
1954 		 struct cifs_tcon *tcon, const unsigned int xid)
1955 {
1956 	int rc = 0;
1957 	u32 oplock = 0;
1958 	FILE_UNIX_BASIC_INFO *info = NULL;
1959 	struct inode *newinode = NULL;
1960 	struct cifs_fattr fattr;
1961 
1962 	info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1963 	if (info == NULL) {
1964 		rc = -ENOMEM;
1965 		goto posix_mkdir_out;
1966 	}
1967 
1968 	mode &= ~current_umask();
1969 	rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1970 			     NULL /* netfid */, info, &oplock, full_path,
1971 			     cifs_sb->local_nls, cifs_remap(cifs_sb));
1972 	if (rc == -EOPNOTSUPP)
1973 		goto posix_mkdir_out;
1974 	else if (rc) {
1975 		cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1976 		d_drop(dentry);
1977 		goto posix_mkdir_out;
1978 	}
1979 
1980 	if (info->Type == cpu_to_le32(-1))
1981 		/* no return info, go query for it */
1982 		goto posix_mkdir_get_info;
1983 	/*
1984 	 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1985 	 * need to set uid/gid.
1986 	 */
1987 
1988 	cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1989 	cifs_fill_uniqueid(inode->i_sb, &fattr);
1990 	newinode = cifs_iget(inode->i_sb, &fattr);
1991 	if (!newinode)
1992 		goto posix_mkdir_get_info;
1993 
1994 	d_instantiate(dentry, newinode);
1995 
1996 #ifdef CONFIG_CIFS_DEBUG2
1997 	cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1998 		 dentry, dentry, newinode);
1999 
2000 	if (newinode->i_nlink != 2)
2001 		cifs_dbg(FYI, "unexpected number of links %d\n",
2002 			 newinode->i_nlink);
2003 #endif
2004 
2005 posix_mkdir_out:
2006 	kfree(info);
2007 	return rc;
2008 posix_mkdir_get_info:
2009 	rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
2010 			      xid);
2011 	goto posix_mkdir_out;
2012 }
2013 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2014 
2015 int cifs_mkdir(struct mnt_idmap *idmap, struct inode *inode,
2016 	       struct dentry *direntry, umode_t mode)
2017 {
2018 	int rc = 0;
2019 	unsigned int xid;
2020 	struct cifs_sb_info *cifs_sb;
2021 	struct tcon_link *tlink;
2022 	struct cifs_tcon *tcon;
2023 	struct TCP_Server_Info *server;
2024 	const char *full_path;
2025 	void *page;
2026 
2027 	cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
2028 		 mode, inode);
2029 
2030 	cifs_sb = CIFS_SB(inode->i_sb);
2031 	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2032 		return -EIO;
2033 	tlink = cifs_sb_tlink(cifs_sb);
2034 	if (IS_ERR(tlink))
2035 		return PTR_ERR(tlink);
2036 	tcon = tlink_tcon(tlink);
2037 
2038 	xid = get_xid();
2039 
2040 	page = alloc_dentry_path();
2041 	full_path = build_path_from_dentry(direntry, page);
2042 	if (IS_ERR(full_path)) {
2043 		rc = PTR_ERR(full_path);
2044 		goto mkdir_out;
2045 	}
2046 
2047 	server = tcon->ses->server;
2048 
2049 	if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
2050 		rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
2051 					      cifs_sb);
2052 		d_drop(direntry); /* for time being always refresh inode info */
2053 		goto mkdir_out;
2054 	}
2055 
2056 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2057 	if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
2058 				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
2059 		rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
2060 				      tcon, xid);
2061 		if (rc != -EOPNOTSUPP)
2062 			goto mkdir_out;
2063 	}
2064 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2065 
2066 	if (!server->ops->mkdir) {
2067 		rc = -ENOSYS;
2068 		goto mkdir_out;
2069 	}
2070 
2071 	/* BB add setting the equivalent of mode via CreateX w/ACLs */
2072 	rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
2073 	if (rc) {
2074 		cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
2075 		d_drop(direntry);
2076 		goto mkdir_out;
2077 	}
2078 
2079 	/* TODO: skip this for smb2/smb3 */
2080 	rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
2081 			      xid);
2082 mkdir_out:
2083 	/*
2084 	 * Force revalidate to get parent dir info when needed since cached
2085 	 * attributes are invalid now.
2086 	 */
2087 	CIFS_I(inode)->time = 0;
2088 	free_dentry_path(page);
2089 	free_xid(xid);
2090 	cifs_put_tlink(tlink);
2091 	return rc;
2092 }
2093 
2094 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
2095 {
2096 	int rc = 0;
2097 	unsigned int xid;
2098 	struct cifs_sb_info *cifs_sb;
2099 	struct tcon_link *tlink;
2100 	struct cifs_tcon *tcon;
2101 	struct TCP_Server_Info *server;
2102 	const char *full_path;
2103 	void *page = alloc_dentry_path();
2104 	struct cifsInodeInfo *cifsInode;
2105 
2106 	cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
2107 
2108 	xid = get_xid();
2109 
2110 	full_path = build_path_from_dentry(direntry, page);
2111 	if (IS_ERR(full_path)) {
2112 		rc = PTR_ERR(full_path);
2113 		goto rmdir_exit;
2114 	}
2115 
2116 	cifs_sb = CIFS_SB(inode->i_sb);
2117 	if (unlikely(cifs_forced_shutdown(cifs_sb))) {
2118 		rc = -EIO;
2119 		goto rmdir_exit;
2120 	}
2121 
2122 	tlink = cifs_sb_tlink(cifs_sb);
2123 	if (IS_ERR(tlink)) {
2124 		rc = PTR_ERR(tlink);
2125 		goto rmdir_exit;
2126 	}
2127 	tcon = tlink_tcon(tlink);
2128 	server = tcon->ses->server;
2129 
2130 	if (!server->ops->rmdir) {
2131 		rc = -ENOSYS;
2132 		cifs_put_tlink(tlink);
2133 		goto rmdir_exit;
2134 	}
2135 
2136 	if (tcon->nodelete) {
2137 		rc = -EACCES;
2138 		cifs_put_tlink(tlink);
2139 		goto rmdir_exit;
2140 	}
2141 
2142 	rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
2143 	cifs_put_tlink(tlink);
2144 
2145 	if (!rc) {
2146 		spin_lock(&d_inode(direntry)->i_lock);
2147 		i_size_write(d_inode(direntry), 0);
2148 		clear_nlink(d_inode(direntry));
2149 		spin_unlock(&d_inode(direntry)->i_lock);
2150 	}
2151 
2152 	cifsInode = CIFS_I(d_inode(direntry));
2153 	/* force revalidate to go get info when needed */
2154 	cifsInode->time = 0;
2155 
2156 	cifsInode = CIFS_I(inode);
2157 	/*
2158 	 * Force revalidate to get parent dir info when needed since cached
2159 	 * attributes are invalid now.
2160 	 */
2161 	cifsInode->time = 0;
2162 
2163 	inode_set_ctime_current(d_inode(direntry));
2164 	inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2165 
2166 rmdir_exit:
2167 	free_dentry_path(page);
2168 	free_xid(xid);
2169 	return rc;
2170 }
2171 
2172 static int
2173 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2174 	       const char *from_path, struct dentry *to_dentry,
2175 	       const char *to_path)
2176 {
2177 	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2178 	struct tcon_link *tlink;
2179 	struct cifs_tcon *tcon;
2180 	struct TCP_Server_Info *server;
2181 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2182 	struct cifs_fid fid;
2183 	struct cifs_open_parms oparms;
2184 	int oplock;
2185 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2186 	int rc;
2187 
2188 	tlink = cifs_sb_tlink(cifs_sb);
2189 	if (IS_ERR(tlink))
2190 		return PTR_ERR(tlink);
2191 	tcon = tlink_tcon(tlink);
2192 	server = tcon->ses->server;
2193 
2194 	if (!server->ops->rename)
2195 		return -ENOSYS;
2196 
2197 	/* try path-based rename first */
2198 	rc = server->ops->rename(xid, tcon, from_dentry,
2199 				 from_path, to_path, cifs_sb);
2200 
2201 	/*
2202 	 * Don't bother with rename by filehandle unless file is busy and
2203 	 * source. Note that cross directory moves do not work with
2204 	 * rename by filehandle to various Windows servers.
2205 	 */
2206 	if (rc == 0 || rc != -EBUSY)
2207 		goto do_rename_exit;
2208 
2209 	/* Don't fall back to using SMB on SMB 2+ mount */
2210 	if (server->vals->protocol_id != 0)
2211 		goto do_rename_exit;
2212 
2213 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2214 	/* open-file renames don't work across directories */
2215 	if (to_dentry->d_parent != from_dentry->d_parent)
2216 		goto do_rename_exit;
2217 
2218 	oparms = (struct cifs_open_parms) {
2219 		.tcon = tcon,
2220 		.cifs_sb = cifs_sb,
2221 		/* open the file to be renamed -- we need DELETE perms */
2222 		.desired_access = DELETE,
2223 		.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
2224 		.disposition = FILE_OPEN,
2225 		.path = from_path,
2226 		.fid = &fid,
2227 	};
2228 
2229 	rc = CIFS_open(xid, &oparms, &oplock, NULL);
2230 	if (rc == 0) {
2231 		rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2232 				(const char *) to_dentry->d_name.name,
2233 				cifs_sb->local_nls, cifs_remap(cifs_sb));
2234 		CIFSSMBClose(xid, tcon, fid.netfid);
2235 	}
2236 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2237 do_rename_exit:
2238 	if (rc == 0)
2239 		d_move(from_dentry, to_dentry);
2240 	cifs_put_tlink(tlink);
2241 	return rc;
2242 }
2243 
2244 int
2245 cifs_rename2(struct mnt_idmap *idmap, struct inode *source_dir,
2246 	     struct dentry *source_dentry, struct inode *target_dir,
2247 	     struct dentry *target_dentry, unsigned int flags)
2248 {
2249 	const char *from_name, *to_name;
2250 	void *page1, *page2;
2251 	struct cifs_sb_info *cifs_sb;
2252 	struct tcon_link *tlink;
2253 	struct cifs_tcon *tcon;
2254 	unsigned int xid;
2255 	int rc, tmprc;
2256 	int retry_count = 0;
2257 	FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2258 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2259 	FILE_UNIX_BASIC_INFO *info_buf_target;
2260 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2261 
2262 	if (flags & ~RENAME_NOREPLACE)
2263 		return -EINVAL;
2264 
2265 	cifs_sb = CIFS_SB(source_dir->i_sb);
2266 	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2267 		return -EIO;
2268 
2269 	tlink = cifs_sb_tlink(cifs_sb);
2270 	if (IS_ERR(tlink))
2271 		return PTR_ERR(tlink);
2272 	tcon = tlink_tcon(tlink);
2273 
2274 	page1 = alloc_dentry_path();
2275 	page2 = alloc_dentry_path();
2276 	xid = get_xid();
2277 
2278 	from_name = build_path_from_dentry(source_dentry, page1);
2279 	if (IS_ERR(from_name)) {
2280 		rc = PTR_ERR(from_name);
2281 		goto cifs_rename_exit;
2282 	}
2283 
2284 	to_name = build_path_from_dentry(target_dentry, page2);
2285 	if (IS_ERR(to_name)) {
2286 		rc = PTR_ERR(to_name);
2287 		goto cifs_rename_exit;
2288 	}
2289 
2290 	cifs_close_deferred_file_under_dentry(tcon, from_name);
2291 	if (d_inode(target_dentry) != NULL)
2292 		cifs_close_deferred_file_under_dentry(tcon, to_name);
2293 
2294 	rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2295 			    to_name);
2296 
2297 	if (rc == -EACCES) {
2298 		while (retry_count < 3) {
2299 			cifs_close_all_deferred_files(tcon);
2300 			rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2301 					    to_name);
2302 			if (rc != -EACCES)
2303 				break;
2304 			retry_count++;
2305 		}
2306 	}
2307 
2308 	/*
2309 	 * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2310 	 */
2311 	if (flags & RENAME_NOREPLACE)
2312 		goto cifs_rename_exit;
2313 
2314 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2315 	if (rc == -EEXIST && tcon->unix_ext) {
2316 		/*
2317 		 * Are src and dst hardlinks of same inode? We can only tell
2318 		 * with unix extensions enabled.
2319 		 */
2320 		info_buf_source =
2321 			kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2322 					GFP_KERNEL);
2323 		if (info_buf_source == NULL) {
2324 			rc = -ENOMEM;
2325 			goto cifs_rename_exit;
2326 		}
2327 
2328 		info_buf_target = info_buf_source + 1;
2329 		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2330 					     info_buf_source,
2331 					     cifs_sb->local_nls,
2332 					     cifs_remap(cifs_sb));
2333 		if (tmprc != 0)
2334 			goto unlink_target;
2335 
2336 		tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2337 					     info_buf_target,
2338 					     cifs_sb->local_nls,
2339 					     cifs_remap(cifs_sb));
2340 
2341 		if (tmprc == 0 && (info_buf_source->UniqueId ==
2342 				   info_buf_target->UniqueId)) {
2343 			/* same file, POSIX says that this is a noop */
2344 			rc = 0;
2345 			goto cifs_rename_exit;
2346 		}
2347 	}
2348 	/*
2349 	 * else ... BB we could add the same check for Windows by
2350 	 * checking the UniqueId via FILE_INTERNAL_INFO
2351 	 */
2352 
2353 unlink_target:
2354 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2355 
2356 	/* Try unlinking the target dentry if it's not negative */
2357 	if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2358 		if (d_is_dir(target_dentry))
2359 			tmprc = cifs_rmdir(target_dir, target_dentry);
2360 		else
2361 			tmprc = cifs_unlink(target_dir, target_dentry);
2362 		if (tmprc)
2363 			goto cifs_rename_exit;
2364 		rc = cifs_do_rename(xid, source_dentry, from_name,
2365 				    target_dentry, to_name);
2366 	}
2367 
2368 	/* force revalidate to go get info when needed */
2369 	CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2370 
2371 cifs_rename_exit:
2372 	kfree(info_buf_source);
2373 	free_dentry_path(page2);
2374 	free_dentry_path(page1);
2375 	free_xid(xid);
2376 	cifs_put_tlink(tlink);
2377 	return rc;
2378 }
2379 
2380 static bool
2381 cifs_dentry_needs_reval(struct dentry *dentry)
2382 {
2383 	struct inode *inode = d_inode(dentry);
2384 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2385 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2386 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2387 	struct cached_fid *cfid = NULL;
2388 
2389 	if (cifs_i->time == 0)
2390 		return true;
2391 
2392 	if (CIFS_CACHE_READ(cifs_i))
2393 		return false;
2394 
2395 	if (!lookupCacheEnabled)
2396 		return true;
2397 
2398 	if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2399 		spin_lock(&cfid->fid_lock);
2400 		if (cfid->time && cifs_i->time > cfid->time) {
2401 			spin_unlock(&cfid->fid_lock);
2402 			close_cached_dir(cfid);
2403 			return false;
2404 		}
2405 		spin_unlock(&cfid->fid_lock);
2406 		close_cached_dir(cfid);
2407 	}
2408 	/*
2409 	 * depending on inode type, check if attribute caching disabled for
2410 	 * files or directories
2411 	 */
2412 	if (S_ISDIR(inode->i_mode)) {
2413 		if (!cifs_sb->ctx->acdirmax)
2414 			return true;
2415 		if (!time_in_range(jiffies, cifs_i->time,
2416 				   cifs_i->time + cifs_sb->ctx->acdirmax))
2417 			return true;
2418 	} else { /* file */
2419 		if (!cifs_sb->ctx->acregmax)
2420 			return true;
2421 		if (!time_in_range(jiffies, cifs_i->time,
2422 				   cifs_i->time + cifs_sb->ctx->acregmax))
2423 			return true;
2424 	}
2425 
2426 	/* hardlinked files w/ noserverino get "special" treatment */
2427 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2428 	    S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2429 		return true;
2430 
2431 	return false;
2432 }
2433 
2434 /*
2435  * Zap the cache. Called when invalid_mapping flag is set.
2436  */
2437 int
2438 cifs_invalidate_mapping(struct inode *inode)
2439 {
2440 	int rc = 0;
2441 
2442 	if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2443 		rc = invalidate_inode_pages2(inode->i_mapping);
2444 		if (rc)
2445 			cifs_dbg(VFS, "%s: invalidate inode %p failed with rc %d\n",
2446 				 __func__, inode, rc);
2447 	}
2448 
2449 	return rc;
2450 }
2451 
2452 /**
2453  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2454  *
2455  * @key:	currently unused
2456  * @mode:	the task state to sleep in
2457  */
2458 static int
2459 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2460 {
2461 	schedule();
2462 	if (signal_pending_state(mode, current))
2463 		return -ERESTARTSYS;
2464 	return 0;
2465 }
2466 
2467 int
2468 cifs_revalidate_mapping(struct inode *inode)
2469 {
2470 	int rc;
2471 	unsigned long *flags = &CIFS_I(inode)->flags;
2472 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2473 
2474 	/* swapfiles are not supposed to be shared */
2475 	if (IS_SWAPFILE(inode))
2476 		return 0;
2477 
2478 	rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2479 				     TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
2480 	if (rc)
2481 		return rc;
2482 
2483 	if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2484 		/* for cache=singleclient, do not invalidate */
2485 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2486 			goto skip_invalidate;
2487 
2488 		rc = cifs_invalidate_mapping(inode);
2489 		if (rc)
2490 			set_bit(CIFS_INO_INVALID_MAPPING, flags);
2491 	}
2492 
2493 skip_invalidate:
2494 	clear_bit_unlock(CIFS_INO_LOCK, flags);
2495 	smp_mb__after_atomic();
2496 	wake_up_bit(flags, CIFS_INO_LOCK);
2497 
2498 	return rc;
2499 }
2500 
2501 int
2502 cifs_zap_mapping(struct inode *inode)
2503 {
2504 	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2505 	return cifs_revalidate_mapping(inode);
2506 }
2507 
2508 int cifs_revalidate_file_attr(struct file *filp)
2509 {
2510 	int rc = 0;
2511 	struct dentry *dentry = file_dentry(filp);
2512 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2513 	struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2514 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2515 
2516 	if (!cifs_dentry_needs_reval(dentry))
2517 		return rc;
2518 
2519 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2520 	if (tlink_tcon(cfile->tlink)->unix_ext)
2521 		rc = cifs_get_file_info_unix(filp);
2522 	else
2523 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2524 		rc = cifs_get_file_info(filp);
2525 
2526 	return rc;
2527 }
2528 
2529 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2530 {
2531 	unsigned int xid;
2532 	int rc = 0;
2533 	struct inode *inode = d_inode(dentry);
2534 	struct super_block *sb = dentry->d_sb;
2535 	const char *full_path;
2536 	void *page;
2537 	int count = 0;
2538 
2539 	if (inode == NULL)
2540 		return -ENOENT;
2541 
2542 	if (!cifs_dentry_needs_reval(dentry))
2543 		return rc;
2544 
2545 	xid = get_xid();
2546 
2547 	page = alloc_dentry_path();
2548 	full_path = build_path_from_dentry(dentry, page);
2549 	if (IS_ERR(full_path)) {
2550 		rc = PTR_ERR(full_path);
2551 		goto out;
2552 	}
2553 
2554 	cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2555 		 full_path, inode, inode->i_count.counter,
2556 		 dentry, cifs_get_time(dentry), jiffies);
2557 
2558 again:
2559 	if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions) {
2560 		rc = smb311_posix_get_inode_info(&inode, full_path,
2561 						 NULL, sb, xid);
2562 	} else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
2563 		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2564 	} else {
2565 		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2566 					 xid, NULL);
2567 	}
2568 	if (rc == -EAGAIN && count++ < 10)
2569 		goto again;
2570 out:
2571 	free_dentry_path(page);
2572 	free_xid(xid);
2573 
2574 	return rc;
2575 }
2576 
2577 int cifs_revalidate_file(struct file *filp)
2578 {
2579 	int rc;
2580 	struct inode *inode = file_inode(filp);
2581 
2582 	rc = cifs_revalidate_file_attr(filp);
2583 	if (rc)
2584 		return rc;
2585 
2586 	return cifs_revalidate_mapping(inode);
2587 }
2588 
2589 /* revalidate a dentry's inode attributes */
2590 int cifs_revalidate_dentry(struct dentry *dentry)
2591 {
2592 	int rc;
2593 	struct inode *inode = d_inode(dentry);
2594 
2595 	rc = cifs_revalidate_dentry_attr(dentry);
2596 	if (rc)
2597 		return rc;
2598 
2599 	return cifs_revalidate_mapping(inode);
2600 }
2601 
2602 int cifs_getattr(struct mnt_idmap *idmap, const struct path *path,
2603 		 struct kstat *stat, u32 request_mask, unsigned int flags)
2604 {
2605 	struct dentry *dentry = path->dentry;
2606 	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2607 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2608 	struct inode *inode = d_inode(dentry);
2609 	int rc;
2610 
2611 	if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2612 		return -EIO;
2613 
2614 	/*
2615 	 * We need to be sure that all dirty pages are written and the server
2616 	 * has actual ctime, mtime and file length.
2617 	 */
2618 	if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2619 	    !CIFS_CACHE_READ(CIFS_I(inode)) &&
2620 	    inode->i_mapping && inode->i_mapping->nrpages != 0) {
2621 		rc = filemap_fdatawait(inode->i_mapping);
2622 		if (rc) {
2623 			mapping_set_error(inode->i_mapping, rc);
2624 			return rc;
2625 		}
2626 	}
2627 
2628 	if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2629 		CIFS_I(inode)->time = 0; /* force revalidate */
2630 
2631 	/*
2632 	 * If the caller doesn't require syncing, only sync if
2633 	 * necessary (e.g. due to earlier truncate or setattr
2634 	 * invalidating the cached metadata)
2635 	 */
2636 	if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2637 	    (CIFS_I(inode)->time == 0)) {
2638 		rc = cifs_revalidate_dentry_attr(dentry);
2639 		if (rc)
2640 			return rc;
2641 	}
2642 
2643 	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
2644 	stat->blksize = cifs_sb->ctx->bsize;
2645 	stat->ino = CIFS_I(inode)->uniqueid;
2646 
2647 	/* old CIFS Unix Extensions doesn't return create time */
2648 	if (CIFS_I(inode)->createtime) {
2649 		stat->result_mask |= STATX_BTIME;
2650 		stat->btime =
2651 		      cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2652 	}
2653 
2654 	stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2655 	if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2656 		stat->attributes |= STATX_ATTR_COMPRESSED;
2657 	if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2658 		stat->attributes |= STATX_ATTR_ENCRYPTED;
2659 
2660 	/*
2661 	 * If on a multiuser mount without unix extensions or cifsacl being
2662 	 * enabled, and the admin hasn't overridden them, set the ownership
2663 	 * to the fsuid/fsgid of the current process.
2664 	 */
2665 	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2666 	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2667 	    !tcon->unix_ext) {
2668 		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2669 			stat->uid = current_fsuid();
2670 		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2671 			stat->gid = current_fsgid();
2672 	}
2673 	return 0;
2674 }
2675 
2676 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2677 		u64 len)
2678 {
2679 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2680 	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->netfs.inode.i_sb);
2681 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2682 	struct TCP_Server_Info *server = tcon->ses->server;
2683 	struct cifsFileInfo *cfile;
2684 	int rc;
2685 
2686 	if (unlikely(cifs_forced_shutdown(cifs_sb)))
2687 		return -EIO;
2688 
2689 	/*
2690 	 * We need to be sure that all dirty pages are written as they
2691 	 * might fill holes on the server.
2692 	 */
2693 	if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2694 	    inode->i_mapping->nrpages != 0) {
2695 		rc = filemap_fdatawait(inode->i_mapping);
2696 		if (rc) {
2697 			mapping_set_error(inode->i_mapping, rc);
2698 			return rc;
2699 		}
2700 	}
2701 
2702 	cfile = find_readable_file(cifs_i, false);
2703 	if (cfile == NULL)
2704 		return -EINVAL;
2705 
2706 	if (server->ops->fiemap) {
2707 		rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2708 		cifsFileInfo_put(cfile);
2709 		return rc;
2710 	}
2711 
2712 	cifsFileInfo_put(cfile);
2713 	return -EOPNOTSUPP;
2714 }
2715 
2716 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2717 {
2718 	pgoff_t index = from >> PAGE_SHIFT;
2719 	unsigned offset = from & (PAGE_SIZE - 1);
2720 	struct page *page;
2721 	int rc = 0;
2722 
2723 	page = grab_cache_page(mapping, index);
2724 	if (!page)
2725 		return -ENOMEM;
2726 
2727 	zero_user_segment(page, offset, PAGE_SIZE);
2728 	unlock_page(page);
2729 	put_page(page);
2730 	return rc;
2731 }
2732 
2733 void cifs_setsize(struct inode *inode, loff_t offset)
2734 {
2735 	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2736 
2737 	spin_lock(&inode->i_lock);
2738 	i_size_write(inode, offset);
2739 	spin_unlock(&inode->i_lock);
2740 
2741 	/* Cached inode must be refreshed on truncate */
2742 	cifs_i->time = 0;
2743 	truncate_pagecache(inode, offset);
2744 }
2745 
2746 static int
2747 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2748 		   unsigned int xid, const char *full_path, struct dentry *dentry)
2749 {
2750 	int rc;
2751 	struct cifsFileInfo *open_file;
2752 	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2753 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2754 	struct tcon_link *tlink = NULL;
2755 	struct cifs_tcon *tcon = NULL;
2756 	struct TCP_Server_Info *server;
2757 
2758 	/*
2759 	 * To avoid spurious oplock breaks from server, in the case of
2760 	 * inodes that we already have open, avoid doing path based
2761 	 * setting of file size if we can do it by handle.
2762 	 * This keeps our caching token (oplock) and avoids timeouts
2763 	 * when the local oplock break takes longer to flush
2764 	 * writebehind data than the SMB timeout for the SetPathInfo
2765 	 * request would allow
2766 	 */
2767 	open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2768 	if (open_file) {
2769 		tcon = tlink_tcon(open_file->tlink);
2770 		server = tcon->ses->server;
2771 		if (server->ops->set_file_size)
2772 			rc = server->ops->set_file_size(xid, tcon, open_file,
2773 							attrs->ia_size, false);
2774 		else
2775 			rc = -ENOSYS;
2776 		cifsFileInfo_put(open_file);
2777 		cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2778 	} else
2779 		rc = -EINVAL;
2780 
2781 	if (!rc)
2782 		goto set_size_out;
2783 
2784 	if (tcon == NULL) {
2785 		tlink = cifs_sb_tlink(cifs_sb);
2786 		if (IS_ERR(tlink))
2787 			return PTR_ERR(tlink);
2788 		tcon = tlink_tcon(tlink);
2789 		server = tcon->ses->server;
2790 	}
2791 
2792 	/*
2793 	 * Set file size by pathname rather than by handle either because no
2794 	 * valid, writeable file handle for it was found or because there was
2795 	 * an error setting it by handle.
2796 	 */
2797 	if (server->ops->set_path_size)
2798 		rc = server->ops->set_path_size(xid, tcon, full_path,
2799 						attrs->ia_size, cifs_sb, false, dentry);
2800 	else
2801 		rc = -ENOSYS;
2802 	cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2803 
2804 	if (tlink)
2805 		cifs_put_tlink(tlink);
2806 
2807 set_size_out:
2808 	if (rc == 0) {
2809 		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
2810 		cifs_setsize(inode, attrs->ia_size);
2811 		/*
2812 		 * i_blocks is not related to (i_size / i_blksize), but instead
2813 		 * 512 byte (2**9) size is required for calculating num blocks.
2814 		 * Until we can query the server for actual allocation size,
2815 		 * this is best estimate we have for blocks allocated for a file
2816 		 * Number of blocks must be rounded up so size 1 is not 0 blocks
2817 		 */
2818 		inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2819 
2820 		/*
2821 		 * The man page of truncate says if the size changed,
2822 		 * then the st_ctime and st_mtime fields for the file
2823 		 * are updated.
2824 		 */
2825 		attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2826 		attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2827 
2828 		cifs_truncate_page(inode->i_mapping, inode->i_size);
2829 	}
2830 
2831 	return rc;
2832 }
2833 
2834 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2835 static int
2836 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2837 {
2838 	int rc;
2839 	unsigned int xid;
2840 	const char *full_path;
2841 	void *page = alloc_dentry_path();
2842 	struct inode *inode = d_inode(direntry);
2843 	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2844 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2845 	struct tcon_link *tlink;
2846 	struct cifs_tcon *pTcon;
2847 	struct cifs_unix_set_info_args *args = NULL;
2848 	struct cifsFileInfo *open_file;
2849 
2850 	cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2851 		 direntry, attrs->ia_valid);
2852 
2853 	xid = get_xid();
2854 
2855 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2856 		attrs->ia_valid |= ATTR_FORCE;
2857 
2858 	rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
2859 	if (rc < 0)
2860 		goto out;
2861 
2862 	full_path = build_path_from_dentry(direntry, page);
2863 	if (IS_ERR(full_path)) {
2864 		rc = PTR_ERR(full_path);
2865 		goto out;
2866 	}
2867 
2868 	/*
2869 	 * Attempt to flush data before changing attributes. We need to do
2870 	 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2871 	 * ownership or mode then we may also need to do this. Here, we take
2872 	 * the safe way out and just do the flush on all setattr requests. If
2873 	 * the flush returns error, store it to report later and continue.
2874 	 *
2875 	 * BB: This should be smarter. Why bother flushing pages that
2876 	 * will be truncated anyway? Also, should we error out here if
2877 	 * the flush returns error?
2878 	 */
2879 	rc = filemap_write_and_wait(inode->i_mapping);
2880 	if (is_interrupt_error(rc)) {
2881 		rc = -ERESTARTSYS;
2882 		goto out;
2883 	}
2884 
2885 	mapping_set_error(inode->i_mapping, rc);
2886 	rc = 0;
2887 
2888 	if (attrs->ia_valid & ATTR_SIZE) {
2889 		rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
2890 		if (rc != 0)
2891 			goto out;
2892 	}
2893 
2894 	/* skip mode change if it's just for clearing setuid/setgid */
2895 	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2896 		attrs->ia_valid &= ~ATTR_MODE;
2897 
2898 	args = kmalloc(sizeof(*args), GFP_KERNEL);
2899 	if (args == NULL) {
2900 		rc = -ENOMEM;
2901 		goto out;
2902 	}
2903 
2904 	/* set up the struct */
2905 	if (attrs->ia_valid & ATTR_MODE)
2906 		args->mode = attrs->ia_mode;
2907 	else
2908 		args->mode = NO_CHANGE_64;
2909 
2910 	if (attrs->ia_valid & ATTR_UID)
2911 		args->uid = attrs->ia_uid;
2912 	else
2913 		args->uid = INVALID_UID; /* no change */
2914 
2915 	if (attrs->ia_valid & ATTR_GID)
2916 		args->gid = attrs->ia_gid;
2917 	else
2918 		args->gid = INVALID_GID; /* no change */
2919 
2920 	if (attrs->ia_valid & ATTR_ATIME)
2921 		args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2922 	else
2923 		args->atime = NO_CHANGE_64;
2924 
2925 	if (attrs->ia_valid & ATTR_MTIME)
2926 		args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2927 	else
2928 		args->mtime = NO_CHANGE_64;
2929 
2930 	if (attrs->ia_valid & ATTR_CTIME)
2931 		args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2932 	else
2933 		args->ctime = NO_CHANGE_64;
2934 
2935 	args->device = 0;
2936 	open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2937 	if (open_file) {
2938 		u16 nfid = open_file->fid.netfid;
2939 		u32 npid = open_file->pid;
2940 		pTcon = tlink_tcon(open_file->tlink);
2941 		rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2942 		cifsFileInfo_put(open_file);
2943 	} else {
2944 		tlink = cifs_sb_tlink(cifs_sb);
2945 		if (IS_ERR(tlink)) {
2946 			rc = PTR_ERR(tlink);
2947 			goto out;
2948 		}
2949 		pTcon = tlink_tcon(tlink);
2950 		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2951 				    cifs_sb->local_nls,
2952 				    cifs_remap(cifs_sb));
2953 		cifs_put_tlink(tlink);
2954 	}
2955 
2956 	if (rc)
2957 		goto out;
2958 
2959 	if ((attrs->ia_valid & ATTR_SIZE) &&
2960 	    attrs->ia_size != i_size_read(inode)) {
2961 		truncate_setsize(inode, attrs->ia_size);
2962 		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
2963 		fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
2964 	}
2965 
2966 	setattr_copy(&nop_mnt_idmap, inode, attrs);
2967 	mark_inode_dirty(inode);
2968 
2969 	/* force revalidate when any of these times are set since some
2970 	   of the fs types (eg ext3, fat) do not have fine enough
2971 	   time granularity to match protocol, and we do not have a
2972 	   a way (yet) to query the server fs's time granularity (and
2973 	   whether it rounds times down).
2974 	*/
2975 	if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2976 		cifsInode->time = 0;
2977 out:
2978 	kfree(args);
2979 	free_dentry_path(page);
2980 	free_xid(xid);
2981 	return rc;
2982 }
2983 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2984 
2985 static int
2986 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2987 {
2988 	unsigned int xid;
2989 	kuid_t uid = INVALID_UID;
2990 	kgid_t gid = INVALID_GID;
2991 	struct inode *inode = d_inode(direntry);
2992 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2993 	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2994 	struct cifsFileInfo *wfile;
2995 	struct cifs_tcon *tcon;
2996 	const char *full_path;
2997 	void *page = alloc_dentry_path();
2998 	int rc = -EACCES;
2999 	__u32 dosattr = 0;
3000 	__u64 mode = NO_CHANGE_64;
3001 
3002 	xid = get_xid();
3003 
3004 	cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
3005 		 direntry, attrs->ia_valid);
3006 
3007 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
3008 		attrs->ia_valid |= ATTR_FORCE;
3009 
3010 	rc = setattr_prepare(&nop_mnt_idmap, direntry, attrs);
3011 	if (rc < 0)
3012 		goto cifs_setattr_exit;
3013 
3014 	full_path = build_path_from_dentry(direntry, page);
3015 	if (IS_ERR(full_path)) {
3016 		rc = PTR_ERR(full_path);
3017 		goto cifs_setattr_exit;
3018 	}
3019 
3020 	/*
3021 	 * Attempt to flush data before changing attributes. We need to do
3022 	 * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
3023 	 * returns error, store it to report later and continue.
3024 	 *
3025 	 * BB: This should be smarter. Why bother flushing pages that
3026 	 * will be truncated anyway? Also, should we error out here if
3027 	 * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
3028 	 */
3029 	if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
3030 		rc = filemap_write_and_wait(inode->i_mapping);
3031 		if (is_interrupt_error(rc)) {
3032 			rc = -ERESTARTSYS;
3033 			goto cifs_setattr_exit;
3034 		}
3035 		mapping_set_error(inode->i_mapping, rc);
3036 	}
3037 
3038 	rc = 0;
3039 
3040 	if ((attrs->ia_valid & ATTR_MTIME) &&
3041 	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
3042 		rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
3043 		if (!rc) {
3044 			tcon = tlink_tcon(wfile->tlink);
3045 			rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
3046 			cifsFileInfo_put(wfile);
3047 			if (rc)
3048 				goto cifs_setattr_exit;
3049 		} else if (rc != -EBADF)
3050 			goto cifs_setattr_exit;
3051 		else
3052 			rc = 0;
3053 	}
3054 
3055 	if (attrs->ia_valid & ATTR_SIZE) {
3056 		rc = cifs_set_file_size(inode, attrs, xid, full_path, direntry);
3057 		if (rc != 0)
3058 			goto cifs_setattr_exit;
3059 	}
3060 
3061 	if (attrs->ia_valid & ATTR_UID)
3062 		uid = attrs->ia_uid;
3063 
3064 	if (attrs->ia_valid & ATTR_GID)
3065 		gid = attrs->ia_gid;
3066 
3067 	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3068 	    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
3069 		if (uid_valid(uid) || gid_valid(gid)) {
3070 			mode = NO_CHANGE_64;
3071 			rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3072 							uid, gid);
3073 			if (rc) {
3074 				cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
3075 					 __func__, rc);
3076 				goto cifs_setattr_exit;
3077 			}
3078 		}
3079 	} else
3080 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
3081 		attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
3082 
3083 	/* skip mode change if it's just for clearing setuid/setgid */
3084 	if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
3085 		attrs->ia_valid &= ~ATTR_MODE;
3086 
3087 	if (attrs->ia_valid & ATTR_MODE) {
3088 		mode = attrs->ia_mode;
3089 		rc = 0;
3090 		if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
3091 		    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
3092 			rc = id_mode_to_cifs_acl(inode, full_path, &mode,
3093 						INVALID_UID, INVALID_GID);
3094 			if (rc) {
3095 				cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
3096 					 __func__, rc);
3097 				goto cifs_setattr_exit;
3098 			}
3099 
3100 			/*
3101 			 * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
3102 			 * Pick up the actual mode bits that were set.
3103 			 */
3104 			if (mode != attrs->ia_mode)
3105 				attrs->ia_mode = mode;
3106 		} else
3107 		if (((mode & S_IWUGO) == 0) &&
3108 		    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
3109 
3110 			dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
3111 
3112 			/* fix up mode if we're not using dynperm */
3113 			if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
3114 				attrs->ia_mode = inode->i_mode & ~S_IWUGO;
3115 		} else if ((mode & S_IWUGO) &&
3116 			   (cifsInode->cifsAttrs & ATTR_READONLY)) {
3117 
3118 			dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
3119 			/* Attributes of 0 are ignored */
3120 			if (dosattr == 0)
3121 				dosattr |= ATTR_NORMAL;
3122 
3123 			/* reset local inode permissions to normal */
3124 			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3125 				attrs->ia_mode &= ~(S_IALLUGO);
3126 				if (S_ISDIR(inode->i_mode))
3127 					attrs->ia_mode |=
3128 						cifs_sb->ctx->dir_mode;
3129 				else
3130 					attrs->ia_mode |=
3131 						cifs_sb->ctx->file_mode;
3132 			}
3133 		} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
3134 			/* ignore mode change - ATTR_READONLY hasn't changed */
3135 			attrs->ia_valid &= ~ATTR_MODE;
3136 		}
3137 	}
3138 
3139 	if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
3140 	    ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
3141 		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
3142 		/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
3143 
3144 		/* Even if error on time set, no sense failing the call if
3145 		the server would set the time to a reasonable value anyway,
3146 		and this check ensures that we are not being called from
3147 		sys_utimes in which case we ought to fail the call back to
3148 		the user when the server rejects the call */
3149 		if ((rc) && (attrs->ia_valid &
3150 				(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
3151 			rc = 0;
3152 	}
3153 
3154 	/* do not need local check to inode_check_ok since the server does
3155 	   that */
3156 	if (rc)
3157 		goto cifs_setattr_exit;
3158 
3159 	if ((attrs->ia_valid & ATTR_SIZE) &&
3160 	    attrs->ia_size != i_size_read(inode)) {
3161 		truncate_setsize(inode, attrs->ia_size);
3162 		netfs_resize_file(&cifsInode->netfs, attrs->ia_size, true);
3163 		fscache_resize_cookie(cifs_inode_cookie(inode), attrs->ia_size);
3164 	}
3165 
3166 	setattr_copy(&nop_mnt_idmap, inode, attrs);
3167 	mark_inode_dirty(inode);
3168 
3169 cifs_setattr_exit:
3170 	free_xid(xid);
3171 	free_dentry_path(page);
3172 	return rc;
3173 }
3174 
3175 int
3176 cifs_setattr(struct mnt_idmap *idmap, struct dentry *direntry,
3177 	     struct iattr *attrs)
3178 {
3179 	struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
3180 	int rc, retries = 0;
3181 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3182 	struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
3183 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3184 
3185 	if (unlikely(cifs_forced_shutdown(cifs_sb)))
3186 		return -EIO;
3187 
3188 	do {
3189 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3190 		if (pTcon->unix_ext)
3191 			rc = cifs_setattr_unix(direntry, attrs);
3192 		else
3193 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3194 			rc = cifs_setattr_nounix(direntry, attrs);
3195 		retries++;
3196 	} while (is_retryable_error(rc) && retries < 2);
3197 
3198 	/* BB: add cifs_setattr_legacy for really old servers */
3199 	return rc;
3200 }
3201