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