• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *   fs/cifs/cifsfs.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2008
5  *   Author(s): Steve French (sfrench@us.ibm.com)
6  *
7  *   Common Internet FileSystem (CIFS) client
8  *
9  *   This library is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU Lesser General Public License as published
11  *   by the Free Software Foundation; either version 2.1 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This library is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
17  *   the GNU Lesser General Public License for more details.
18  *
19  *   You should have received a copy of the GNU Lesser General Public License
20  *   along with this library; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23 
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
25 
26 #include <linux/module.h>
27 #include <linux/fs.h>
28 #include <linux/mount.h>
29 #include <linux/slab.h>
30 #include <linux/init.h>
31 #include <linux/list.h>
32 #include <linux/seq_file.h>
33 #include <linux/vfs.h>
34 #include <linux/mempool.h>
35 #include <linux/delay.h>
36 #include <linux/kthread.h>
37 #include <linux/freezer.h>
38 #include <linux/namei.h>
39 #include <linux/random.h>
40 #include <linux/uuid.h>
41 #include <linux/xattr.h>
42 #include <net/ipv6.h>
43 #include "cifsfs.h"
44 #include "cifspdu.h"
45 #define DECLARE_GLOBALS_HERE
46 #include "cifsglob.h"
47 #include "cifsproto.h"
48 #include "cifs_debug.h"
49 #include "cifs_fs_sb.h"
50 #include <linux/mm.h>
51 #include <linux/key-type.h>
52 #include "cifs_spnego.h"
53 #include "fscache.h"
54 #include "smb2pdu.h"
55 #ifdef CONFIG_CIFS_DFS_UPCALL
56 #include "dfs_cache.h"
57 #endif
58 
59 /*
60  * DOS dates from 1980/1/1 through 2107/12/31
61  * Protocol specifications indicate the range should be to 119, which
62  * limits maximum year to 2099. But this range has not been checked.
63  */
64 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
65 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
66 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
67 
68 int cifsFYI = 0;
69 bool traceSMB;
70 bool enable_oplocks = true;
71 bool linuxExtEnabled = true;
72 bool lookupCacheEnabled = true;
73 bool disable_legacy_dialects; /* false by default */
74 bool enable_gcm_256;  /* false by default, change when more servers support it */
75 bool require_gcm_256; /* false by default */
76 unsigned int global_secflags = CIFSSEC_DEF;
77 /* unsigned int ntlmv2_support = 0; */
78 unsigned int sign_CIFS_PDUs = 1;
79 static const struct super_operations cifs_super_ops;
80 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
81 module_param(CIFSMaxBufSize, uint, 0444);
82 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
83 				 "for CIFS requests. "
84 				 "Default: 16384 Range: 8192 to 130048");
85 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
86 module_param(cifs_min_rcv, uint, 0444);
87 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
88 				"1 to 64");
89 unsigned int cifs_min_small = 30;
90 module_param(cifs_min_small, uint, 0444);
91 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
92 				 "Range: 2 to 256");
93 unsigned int cifs_max_pending = CIFS_MAX_REQ;
94 module_param(cifs_max_pending, uint, 0444);
95 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
96 				   "CIFS/SMB1 dialect (N/A for SMB3) "
97 				   "Default: 32767 Range: 2 to 32767.");
98 #ifdef CONFIG_CIFS_STATS2
99 unsigned int slow_rsp_threshold = 1;
100 module_param(slow_rsp_threshold, uint, 0644);
101 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
102 				   "before logging that a response is delayed. "
103 				   "Default: 1 (if set to 0 disables msg).");
104 #endif /* STATS2 */
105 
106 module_param(enable_oplocks, bool, 0644);
107 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
108 
109 module_param(enable_gcm_256, bool, 0644);
110 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
111 
112 module_param(require_gcm_256, bool, 0644);
113 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
114 
115 module_param(disable_legacy_dialects, bool, 0644);
116 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
117 				  "helpful to restrict the ability to "
118 				  "override the default dialects (SMB2.1, "
119 				  "SMB3 and SMB3.02) on mount with old "
120 				  "dialects (CIFS/SMB1 and SMB2) since "
121 				  "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
122 				  " and less secure. Default: n/N/0");
123 
124 extern mempool_t *cifs_sm_req_poolp;
125 extern mempool_t *cifs_req_poolp;
126 extern mempool_t *cifs_mid_poolp;
127 
128 struct workqueue_struct	*cifsiod_wq;
129 struct workqueue_struct	*decrypt_wq;
130 struct workqueue_struct	*fileinfo_put_wq;
131 struct workqueue_struct	*cifsoplockd_wq;
132 __u32 cifs_lock_secret;
133 
134 /*
135  * Bumps refcount for cifs super block.
136  * Note that it should be only called if a referece to VFS super block is
137  * already held, e.g. in open-type syscalls context. Otherwise it can race with
138  * atomic_dec_and_test in deactivate_locked_super.
139  */
140 void
cifs_sb_active(struct super_block * sb)141 cifs_sb_active(struct super_block *sb)
142 {
143 	struct cifs_sb_info *server = CIFS_SB(sb);
144 
145 	if (atomic_inc_return(&server->active) == 1)
146 		atomic_inc(&sb->s_active);
147 }
148 
149 void
cifs_sb_deactive(struct super_block * sb)150 cifs_sb_deactive(struct super_block *sb)
151 {
152 	struct cifs_sb_info *server = CIFS_SB(sb);
153 
154 	if (atomic_dec_and_test(&server->active))
155 		deactivate_super(sb);
156 }
157 
158 static int
cifs_read_super(struct super_block * sb)159 cifs_read_super(struct super_block *sb)
160 {
161 	struct inode *inode;
162 	struct cifs_sb_info *cifs_sb;
163 	struct cifs_tcon *tcon;
164 	struct timespec64 ts;
165 	int rc = 0;
166 
167 	cifs_sb = CIFS_SB(sb);
168 	tcon = cifs_sb_master_tcon(cifs_sb);
169 
170 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
171 		sb->s_flags |= SB_POSIXACL;
172 
173 	if (tcon->snapshot_time)
174 		sb->s_flags |= SB_RDONLY;
175 
176 	if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
177 		sb->s_maxbytes = MAX_LFS_FILESIZE;
178 	else
179 		sb->s_maxbytes = MAX_NON_LFS;
180 
181 	/*
182 	 * Some very old servers like DOS and OS/2 used 2 second granularity
183 	 * (while all current servers use 100ns granularity - see MS-DTYP)
184 	 * but 1 second is the maximum allowed granularity for the VFS
185 	 * so for old servers set time granularity to 1 second while for
186 	 * everything else (current servers) set it to 100ns.
187 	 */
188 	if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
189 	    ((tcon->ses->capabilities &
190 	      tcon->ses->server->vals->cap_nt_find) == 0) &&
191 	    !tcon->unix_ext) {
192 		sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
193 		ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
194 		sb->s_time_min = ts.tv_sec;
195 		ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
196 				    cpu_to_le16(SMB_TIME_MAX), 0);
197 		sb->s_time_max = ts.tv_sec;
198 	} else {
199 		/*
200 		 * Almost every server, including all SMB2+, uses DCE TIME
201 		 * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
202 		 */
203 		sb->s_time_gran = 100;
204 		ts = cifs_NTtimeToUnix(0);
205 		sb->s_time_min = ts.tv_sec;
206 		ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
207 		sb->s_time_max = ts.tv_sec;
208 	}
209 
210 	sb->s_magic = CIFS_MAGIC_NUMBER;
211 	sb->s_op = &cifs_super_ops;
212 	sb->s_xattr = cifs_xattr_handlers;
213 	rc = super_setup_bdi(sb);
214 	if (rc)
215 		goto out_no_root;
216 	/* tune readahead according to rsize */
217 	sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
218 
219 	sb->s_blocksize = CIFS_MAX_MSGSIZE;
220 	sb->s_blocksize_bits = 14;	/* default 2**14 = CIFS_MAX_MSGSIZE */
221 	inode = cifs_root_iget(sb);
222 
223 	if (IS_ERR(inode)) {
224 		rc = PTR_ERR(inode);
225 		goto out_no_root;
226 	}
227 
228 	if (tcon->nocase)
229 		sb->s_d_op = &cifs_ci_dentry_ops;
230 	else
231 		sb->s_d_op = &cifs_dentry_ops;
232 
233 	sb->s_root = d_make_root(inode);
234 	if (!sb->s_root) {
235 		rc = -ENOMEM;
236 		goto out_no_root;
237 	}
238 
239 #ifdef CONFIG_CIFS_NFSD_EXPORT
240 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
241 		cifs_dbg(FYI, "export ops supported\n");
242 		sb->s_export_op = &cifs_export_ops;
243 	}
244 #endif /* CONFIG_CIFS_NFSD_EXPORT */
245 
246 	return 0;
247 
248 out_no_root:
249 	cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
250 	return rc;
251 }
252 
cifs_kill_sb(struct super_block * sb)253 static void cifs_kill_sb(struct super_block *sb)
254 {
255 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
256 	kill_anon_super(sb);
257 	cifs_umount(cifs_sb);
258 }
259 
260 static int
cifs_statfs(struct dentry * dentry,struct kstatfs * buf)261 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
262 {
263 	struct super_block *sb = dentry->d_sb;
264 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
265 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
266 	struct TCP_Server_Info *server = tcon->ses->server;
267 	unsigned int xid;
268 	int rc = 0;
269 
270 	xid = get_xid();
271 
272 	if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
273 		buf->f_namelen =
274 		       le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
275 	else
276 		buf->f_namelen = PATH_MAX;
277 
278 	buf->f_fsid.val[0] = tcon->vol_serial_number;
279 	/* are using part of create time for more randomness, see man statfs */
280 	buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
281 
282 	buf->f_files = 0;	/* undefined */
283 	buf->f_ffree = 0;	/* unlimited */
284 
285 	if (server->ops->queryfs)
286 		rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
287 
288 	free_xid(xid);
289 	return rc;
290 }
291 
cifs_fallocate(struct file * file,int mode,loff_t off,loff_t len)292 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
293 {
294 	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
295 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
296 	struct TCP_Server_Info *server = tcon->ses->server;
297 
298 	if (server->ops->fallocate)
299 		return server->ops->fallocate(file, tcon, mode, off, len);
300 
301 	return -EOPNOTSUPP;
302 }
303 
cifs_permission(struct inode * inode,int mask)304 static int cifs_permission(struct inode *inode, int mask)
305 {
306 	struct cifs_sb_info *cifs_sb;
307 
308 	cifs_sb = CIFS_SB(inode->i_sb);
309 
310 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
311 		if ((mask & MAY_EXEC) && !execute_ok(inode))
312 			return -EACCES;
313 		else
314 			return 0;
315 	} else /* file mode might have been restricted at mount time
316 		on the client (above and beyond ACL on servers) for
317 		servers which do not support setting and viewing mode bits,
318 		so allowing client to check permissions is useful */
319 		return generic_permission(inode, mask);
320 }
321 
322 static struct kmem_cache *cifs_inode_cachep;
323 static struct kmem_cache *cifs_req_cachep;
324 static struct kmem_cache *cifs_mid_cachep;
325 static struct kmem_cache *cifs_sm_req_cachep;
326 mempool_t *cifs_sm_req_poolp;
327 mempool_t *cifs_req_poolp;
328 mempool_t *cifs_mid_poolp;
329 
330 static struct inode *
cifs_alloc_inode(struct super_block * sb)331 cifs_alloc_inode(struct super_block *sb)
332 {
333 	struct cifsInodeInfo *cifs_inode;
334 	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
335 	if (!cifs_inode)
336 		return NULL;
337 	cifs_inode->cifsAttrs = 0x20;	/* default */
338 	cifs_inode->time = 0;
339 	/*
340 	 * Until the file is open and we have gotten oplock info back from the
341 	 * server, can not assume caching of file data or metadata.
342 	 */
343 	cifs_set_oplock_level(cifs_inode, 0);
344 	cifs_inode->flags = 0;
345 	spin_lock_init(&cifs_inode->writers_lock);
346 	cifs_inode->writers = 0;
347 	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
348 	cifs_inode->server_eof = 0;
349 	cifs_inode->uniqueid = 0;
350 	cifs_inode->createtime = 0;
351 	cifs_inode->epoch = 0;
352 	spin_lock_init(&cifs_inode->open_file_lock);
353 	generate_random_uuid(cifs_inode->lease_key);
354 
355 	/*
356 	 * Can not set i_flags here - they get immediately overwritten to zero
357 	 * by the VFS.
358 	 */
359 	/* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
360 	INIT_LIST_HEAD(&cifs_inode->openFileList);
361 	INIT_LIST_HEAD(&cifs_inode->llist);
362 	return &cifs_inode->vfs_inode;
363 }
364 
365 static void
cifs_free_inode(struct inode * inode)366 cifs_free_inode(struct inode *inode)
367 {
368 	kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
369 }
370 
371 static void
cifs_evict_inode(struct inode * inode)372 cifs_evict_inode(struct inode *inode)
373 {
374 	truncate_inode_pages_final(&inode->i_data);
375 	clear_inode(inode);
376 	cifs_fscache_release_inode_cookie(inode);
377 }
378 
379 static void
cifs_show_address(struct seq_file * s,struct TCP_Server_Info * server)380 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
381 {
382 	struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
383 	struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
384 
385 	seq_puts(s, ",addr=");
386 
387 	switch (server->dstaddr.ss_family) {
388 	case AF_INET:
389 		seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
390 		break;
391 	case AF_INET6:
392 		seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
393 		if (sa6->sin6_scope_id)
394 			seq_printf(s, "%%%u", sa6->sin6_scope_id);
395 		break;
396 	default:
397 		seq_puts(s, "(unknown)");
398 	}
399 	if (server->rdma)
400 		seq_puts(s, ",rdma");
401 }
402 
403 static void
cifs_show_security(struct seq_file * s,struct cifs_ses * ses)404 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
405 {
406 	if (ses->sectype == Unspecified) {
407 		if (ses->user_name == NULL)
408 			seq_puts(s, ",sec=none");
409 		return;
410 	}
411 
412 	seq_puts(s, ",sec=");
413 
414 	switch (ses->sectype) {
415 	case LANMAN:
416 		seq_puts(s, "lanman");
417 		break;
418 	case NTLMv2:
419 		seq_puts(s, "ntlmv2");
420 		break;
421 	case NTLM:
422 		seq_puts(s, "ntlm");
423 		break;
424 	case Kerberos:
425 		seq_puts(s, "krb5");
426 		break;
427 	case RawNTLMSSP:
428 		seq_puts(s, "ntlmssp");
429 		break;
430 	default:
431 		/* shouldn't ever happen */
432 		seq_puts(s, "unknown");
433 		break;
434 	}
435 
436 	if (ses->sign)
437 		seq_puts(s, "i");
438 
439 	if (ses->sectype == Kerberos)
440 		seq_printf(s, ",cruid=%u",
441 			   from_kuid_munged(&init_user_ns, ses->cred_uid));
442 }
443 
444 static void
cifs_show_cache_flavor(struct seq_file * s,struct cifs_sb_info * cifs_sb)445 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
446 {
447 	seq_puts(s, ",cache=");
448 
449 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
450 		seq_puts(s, "strict");
451 	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
452 		seq_puts(s, "none");
453 	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
454 		seq_puts(s, "singleclient"); /* assume only one client access */
455 	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
456 		seq_puts(s, "ro"); /* read only caching assumed */
457 	else
458 		seq_puts(s, "loose");
459 }
460 
461 static void
cifs_show_nls(struct seq_file * s,struct nls_table * cur)462 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
463 {
464 	struct nls_table *def;
465 
466 	/* Display iocharset= option if it's not default charset */
467 	def = load_nls_default();
468 	if (def != cur)
469 		seq_printf(s, ",iocharset=%s", cur->charset);
470 	unload_nls(def);
471 }
472 
473 /*
474  * cifs_show_options() is for displaying mount options in /proc/mounts.
475  * Not all settable options are displayed but most of the important
476  * ones are.
477  */
478 static int
cifs_show_options(struct seq_file * s,struct dentry * root)479 cifs_show_options(struct seq_file *s, struct dentry *root)
480 {
481 	struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
482 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
483 	struct sockaddr *srcaddr;
484 	srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
485 
486 	seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
487 	cifs_show_security(s, tcon->ses);
488 	cifs_show_cache_flavor(s, cifs_sb);
489 
490 	if (tcon->no_lease)
491 		seq_puts(s, ",nolease");
492 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
493 		seq_puts(s, ",multiuser");
494 	else if (tcon->ses->user_name)
495 		seq_show_option(s, "username", tcon->ses->user_name);
496 
497 	if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
498 		seq_show_option(s, "domain", tcon->ses->domainName);
499 
500 	if (srcaddr->sa_family != AF_UNSPEC) {
501 		struct sockaddr_in *saddr4;
502 		struct sockaddr_in6 *saddr6;
503 		saddr4 = (struct sockaddr_in *)srcaddr;
504 		saddr6 = (struct sockaddr_in6 *)srcaddr;
505 		if (srcaddr->sa_family == AF_INET6)
506 			seq_printf(s, ",srcaddr=%pI6c",
507 				   &saddr6->sin6_addr);
508 		else if (srcaddr->sa_family == AF_INET)
509 			seq_printf(s, ",srcaddr=%pI4",
510 				   &saddr4->sin_addr.s_addr);
511 		else
512 			seq_printf(s, ",srcaddr=BAD-AF:%i",
513 				   (int)(srcaddr->sa_family));
514 	}
515 
516 	seq_printf(s, ",uid=%u",
517 		   from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
518 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
519 		seq_puts(s, ",forceuid");
520 	else
521 		seq_puts(s, ",noforceuid");
522 
523 	seq_printf(s, ",gid=%u",
524 		   from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
525 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
526 		seq_puts(s, ",forcegid");
527 	else
528 		seq_puts(s, ",noforcegid");
529 
530 	cifs_show_address(s, tcon->ses->server);
531 
532 	if (!tcon->unix_ext)
533 		seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
534 					   cifs_sb->mnt_file_mode,
535 					   cifs_sb->mnt_dir_mode);
536 
537 	cifs_show_nls(s, cifs_sb->local_nls);
538 
539 	if (tcon->seal)
540 		seq_puts(s, ",seal");
541 	else if (tcon->ses->server->ignore_signature)
542 		seq_puts(s, ",signloosely");
543 	if (tcon->nocase)
544 		seq_puts(s, ",nocase");
545 	if (tcon->nodelete)
546 		seq_puts(s, ",nodelete");
547 	if (tcon->local_lease)
548 		seq_puts(s, ",locallease");
549 	if (tcon->retry)
550 		seq_puts(s, ",hard");
551 	else
552 		seq_puts(s, ",soft");
553 	if (tcon->use_persistent)
554 		seq_puts(s, ",persistenthandles");
555 	else if (tcon->use_resilient)
556 		seq_puts(s, ",resilienthandles");
557 	if (tcon->posix_extensions)
558 		seq_puts(s, ",posix");
559 	else if (tcon->unix_ext)
560 		seq_puts(s, ",unix");
561 	else
562 		seq_puts(s, ",nounix");
563 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
564 		seq_puts(s, ",nodfs");
565 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
566 		seq_puts(s, ",posixpaths");
567 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
568 		seq_puts(s, ",setuids");
569 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
570 		seq_puts(s, ",idsfromsid");
571 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
572 		seq_puts(s, ",serverino");
573 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
574 		seq_puts(s, ",rwpidforward");
575 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
576 		seq_puts(s, ",forcemand");
577 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
578 		seq_puts(s, ",nouser_xattr");
579 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
580 		seq_puts(s, ",mapchars");
581 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
582 		seq_puts(s, ",mapposix");
583 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
584 		seq_puts(s, ",sfu");
585 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
586 		seq_puts(s, ",nobrl");
587 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
588 		seq_puts(s, ",nohandlecache");
589 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
590 		seq_puts(s, ",modefromsid");
591 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
592 		seq_puts(s, ",cifsacl");
593 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
594 		seq_puts(s, ",dynperm");
595 	if (root->d_sb->s_flags & SB_POSIXACL)
596 		seq_puts(s, ",acl");
597 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
598 		seq_puts(s, ",mfsymlinks");
599 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
600 		seq_puts(s, ",fsc");
601 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
602 		seq_puts(s, ",nostrictsync");
603 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
604 		seq_puts(s, ",noperm");
605 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
606 		seq_printf(s, ",backupuid=%u",
607 			   from_kuid_munged(&init_user_ns,
608 					    cifs_sb->mnt_backupuid));
609 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
610 		seq_printf(s, ",backupgid=%u",
611 			   from_kgid_munged(&init_user_ns,
612 					    cifs_sb->mnt_backupgid));
613 
614 	seq_printf(s, ",rsize=%u", cifs_sb->rsize);
615 	seq_printf(s, ",wsize=%u", cifs_sb->wsize);
616 	seq_printf(s, ",bsize=%u", cifs_sb->bsize);
617 	if (tcon->ses->server->min_offload)
618 		seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
619 	seq_printf(s, ",echo_interval=%lu",
620 			tcon->ses->server->echo_interval / HZ);
621 
622 	/* Only display the following if overridden on mount */
623 	if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
624 		seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
625 	if (tcon->ses->server->tcp_nodelay)
626 		seq_puts(s, ",tcpnodelay");
627 	if (tcon->ses->server->noautotune)
628 		seq_puts(s, ",noautotune");
629 	if (tcon->ses->server->noblocksnd)
630 		seq_puts(s, ",noblocksend");
631 
632 	if (tcon->snapshot_time)
633 		seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
634 	if (tcon->handle_timeout)
635 		seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
636 	/* convert actimeo and display it in seconds */
637 	seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
638 
639 	if (tcon->ses->chan_max > 1)
640 		seq_printf(s, ",multichannel,max_channels=%zu",
641 			   tcon->ses->chan_max);
642 
643 	return 0;
644 }
645 
cifs_umount_begin(struct super_block * sb)646 static void cifs_umount_begin(struct super_block *sb)
647 {
648 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
649 	struct cifs_tcon *tcon;
650 
651 	if (cifs_sb == NULL)
652 		return;
653 
654 	tcon = cifs_sb_master_tcon(cifs_sb);
655 
656 	spin_lock(&cifs_tcp_ses_lock);
657 	if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
658 		/* we have other mounts to same share or we have
659 		   already tried to force umount this and woken up
660 		   all waiting network requests, nothing to do */
661 		spin_unlock(&cifs_tcp_ses_lock);
662 		return;
663 	} else if (tcon->tc_count == 1)
664 		tcon->tidStatus = CifsExiting;
665 	spin_unlock(&cifs_tcp_ses_lock);
666 
667 	/* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
668 	/* cancel_notify_requests(tcon); */
669 	if (tcon->ses && tcon->ses->server) {
670 		cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
671 		wake_up_all(&tcon->ses->server->request_q);
672 		wake_up_all(&tcon->ses->server->response_q);
673 		msleep(1); /* yield */
674 		/* we have to kick the requests once more */
675 		wake_up_all(&tcon->ses->server->response_q);
676 		msleep(1);
677 	}
678 
679 	return;
680 }
681 
682 #ifdef CONFIG_CIFS_STATS2
cifs_show_stats(struct seq_file * s,struct dentry * root)683 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
684 {
685 	/* BB FIXME */
686 	return 0;
687 }
688 #endif
689 
cifs_remount(struct super_block * sb,int * flags,char * data)690 static int cifs_remount(struct super_block *sb, int *flags, char *data)
691 {
692 	sync_filesystem(sb);
693 	*flags |= SB_NODIRATIME;
694 	return 0;
695 }
696 
cifs_drop_inode(struct inode * inode)697 static int cifs_drop_inode(struct inode *inode)
698 {
699 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
700 
701 	/* no serverino => unconditional eviction */
702 	return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
703 		generic_drop_inode(inode);
704 }
705 
706 static const struct super_operations cifs_super_ops = {
707 	.statfs = cifs_statfs,
708 	.alloc_inode = cifs_alloc_inode,
709 	.free_inode = cifs_free_inode,
710 	.drop_inode	= cifs_drop_inode,
711 	.evict_inode	= cifs_evict_inode,
712 /*	.delete_inode	= cifs_delete_inode,  */  /* Do not need above
713 	function unless later we add lazy close of inodes or unless the
714 	kernel forgets to call us with the same number of releases (closes)
715 	as opens */
716 	.show_options = cifs_show_options,
717 	.umount_begin   = cifs_umount_begin,
718 	.remount_fs = cifs_remount,
719 #ifdef CONFIG_CIFS_STATS2
720 	.show_stats = cifs_show_stats,
721 #endif
722 };
723 
724 /*
725  * Get root dentry from superblock according to prefix path mount option.
726  * Return dentry with refcount + 1 on success and NULL otherwise.
727  */
728 static struct dentry *
cifs_get_root(struct smb_vol * vol,struct super_block * sb)729 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
730 {
731 	struct dentry *dentry;
732 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
733 	char *full_path = NULL;
734 	char *s, *p;
735 	char sep;
736 
737 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
738 		return dget(sb->s_root);
739 
740 	full_path = cifs_build_path_to_root(vol, cifs_sb,
741 				cifs_sb_master_tcon(cifs_sb), 0);
742 	if (full_path == NULL)
743 		return ERR_PTR(-ENOMEM);
744 
745 	cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
746 
747 	sep = CIFS_DIR_SEP(cifs_sb);
748 	dentry = dget(sb->s_root);
749 	p = s = full_path;
750 
751 	do {
752 		struct inode *dir = d_inode(dentry);
753 		struct dentry *child;
754 
755 		if (!S_ISDIR(dir->i_mode)) {
756 			dput(dentry);
757 			dentry = ERR_PTR(-ENOTDIR);
758 			break;
759 		}
760 
761 		/* skip separators */
762 		while (*s == sep)
763 			s++;
764 		if (!*s)
765 			break;
766 		p = s++;
767 		/* next separator */
768 		while (*s && *s != sep)
769 			s++;
770 
771 		child = lookup_positive_unlocked(p, dentry, s - p);
772 		dput(dentry);
773 		dentry = child;
774 	} while (!IS_ERR(dentry));
775 	kfree(full_path);
776 	return dentry;
777 }
778 
cifs_set_super(struct super_block * sb,void * data)779 static int cifs_set_super(struct super_block *sb, void *data)
780 {
781 	struct cifs_mnt_data *mnt_data = data;
782 	sb->s_fs_info = mnt_data->cifs_sb;
783 	return set_anon_super(sb, NULL);
784 }
785 
786 static struct dentry *
cifs_smb3_do_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data,bool is_smb3)787 cifs_smb3_do_mount(struct file_system_type *fs_type,
788 	      int flags, const char *dev_name, void *data, bool is_smb3)
789 {
790 	int rc;
791 	struct super_block *sb;
792 	struct cifs_sb_info *cifs_sb;
793 	struct smb_vol *volume_info;
794 	struct cifs_mnt_data mnt_data;
795 	struct dentry *root;
796 
797 	/*
798 	 * Prints in Kernel / CIFS log the attempted mount operation
799 	 *	If CIFS_DEBUG && cifs_FYI
800 	 */
801 	if (cifsFYI)
802 		cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
803 	else
804 		cifs_info("Attempting to mount %s\n", dev_name);
805 
806 	volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
807 	if (IS_ERR(volume_info))
808 		return ERR_CAST(volume_info);
809 
810 	cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
811 	if (cifs_sb == NULL) {
812 		root = ERR_PTR(-ENOMEM);
813 		goto out_nls;
814 	}
815 
816 	cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
817 	if (cifs_sb->mountdata == NULL) {
818 		root = ERR_PTR(-ENOMEM);
819 		goto out_free;
820 	}
821 
822 	rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
823 	if (rc) {
824 		root = ERR_PTR(rc);
825 		goto out_free;
826 	}
827 
828 	rc = cifs_mount(cifs_sb, volume_info);
829 	if (rc) {
830 		if (!(flags & SB_SILENT))
831 			cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
832 				 rc);
833 		root = ERR_PTR(rc);
834 		goto out_free;
835 	}
836 
837 	mnt_data.vol = volume_info;
838 	mnt_data.cifs_sb = cifs_sb;
839 	mnt_data.flags = flags;
840 
841 	/* BB should we make this contingent on mount parm? */
842 	flags |= SB_NODIRATIME | SB_NOATIME;
843 
844 	sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
845 	if (IS_ERR(sb)) {
846 		root = ERR_CAST(sb);
847 		cifs_umount(cifs_sb);
848 		goto out;
849 	}
850 
851 	if (sb->s_root) {
852 		cifs_dbg(FYI, "Use existing superblock\n");
853 		cifs_umount(cifs_sb);
854 	} else {
855 		rc = cifs_read_super(sb);
856 		if (rc) {
857 			root = ERR_PTR(rc);
858 			goto out_super;
859 		}
860 
861 		sb->s_flags |= SB_ACTIVE;
862 	}
863 
864 	root = cifs_get_root(volume_info, sb);
865 	if (IS_ERR(root))
866 		goto out_super;
867 
868 	cifs_dbg(FYI, "dentry root is: %p\n", root);
869 	goto out;
870 
871 out_super:
872 	deactivate_locked_super(sb);
873 	return root;
874 out:
875 	cifs_cleanup_volume_info(volume_info);
876 	return root;
877 
878 out_free:
879 	kfree(cifs_sb->prepath);
880 	kfree(cifs_sb->mountdata);
881 	kfree(cifs_sb);
882 out_nls:
883 	unload_nls(volume_info->local_nls);
884 	goto out;
885 }
886 
887 static struct dentry *
smb3_do_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)888 smb3_do_mount(struct file_system_type *fs_type,
889 	      int flags, const char *dev_name, void *data)
890 {
891 	return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
892 }
893 
894 static struct dentry *
cifs_do_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)895 cifs_do_mount(struct file_system_type *fs_type,
896 	      int flags, const char *dev_name, void *data)
897 {
898 	return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
899 }
900 
901 static ssize_t
cifs_loose_read_iter(struct kiocb * iocb,struct iov_iter * iter)902 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
903 {
904 	ssize_t rc;
905 	struct inode *inode = file_inode(iocb->ki_filp);
906 
907 	if (iocb->ki_flags & IOCB_DIRECT)
908 		return cifs_user_readv(iocb, iter);
909 
910 	rc = cifs_revalidate_mapping(inode);
911 	if (rc)
912 		return rc;
913 
914 	return generic_file_read_iter(iocb, iter);
915 }
916 
cifs_file_write_iter(struct kiocb * iocb,struct iov_iter * from)917 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
918 {
919 	struct inode *inode = file_inode(iocb->ki_filp);
920 	struct cifsInodeInfo *cinode = CIFS_I(inode);
921 	ssize_t written;
922 	int rc;
923 
924 	if (iocb->ki_filp->f_flags & O_DIRECT) {
925 		written = cifs_user_writev(iocb, from);
926 		if (written > 0 && CIFS_CACHE_READ(cinode)) {
927 			cifs_zap_mapping(inode);
928 			cifs_dbg(FYI,
929 				 "Set no oplock for inode=%p after a write operation\n",
930 				 inode);
931 			cinode->oplock = 0;
932 		}
933 		return written;
934 	}
935 
936 	written = cifs_get_writer(cinode);
937 	if (written)
938 		return written;
939 
940 	written = generic_file_write_iter(iocb, from);
941 
942 	if (CIFS_CACHE_WRITE(CIFS_I(inode)))
943 		goto out;
944 
945 	rc = filemap_fdatawrite(inode->i_mapping);
946 	if (rc)
947 		cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
948 			 rc, inode);
949 
950 out:
951 	cifs_put_writer(cinode);
952 	return written;
953 }
954 
cifs_llseek(struct file * file,loff_t offset,int whence)955 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
956 {
957 	struct cifsFileInfo *cfile = file->private_data;
958 	struct cifs_tcon *tcon;
959 
960 	/*
961 	 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
962 	 * the cached file length
963 	 */
964 	if (whence != SEEK_SET && whence != SEEK_CUR) {
965 		int rc;
966 		struct inode *inode = file_inode(file);
967 
968 		/*
969 		 * We need to be sure that all dirty pages are written and the
970 		 * server has the newest file length.
971 		 */
972 		if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
973 		    inode->i_mapping->nrpages != 0) {
974 			rc = filemap_fdatawait(inode->i_mapping);
975 			if (rc) {
976 				mapping_set_error(inode->i_mapping, rc);
977 				return rc;
978 			}
979 		}
980 		/*
981 		 * Some applications poll for the file length in this strange
982 		 * way so we must seek to end on non-oplocked files by
983 		 * setting the revalidate time to zero.
984 		 */
985 		CIFS_I(inode)->time = 0;
986 
987 		rc = cifs_revalidate_file_attr(file);
988 		if (rc < 0)
989 			return (loff_t)rc;
990 	}
991 	if (cfile && cfile->tlink) {
992 		tcon = tlink_tcon(cfile->tlink);
993 		if (tcon->ses->server->ops->llseek)
994 			return tcon->ses->server->ops->llseek(file, tcon,
995 							      offset, whence);
996 	}
997 	return generic_file_llseek(file, offset, whence);
998 }
999 
1000 static int
cifs_setlease(struct file * file,long arg,struct file_lock ** lease,void ** priv)1001 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1002 {
1003 	/*
1004 	 * Note that this is called by vfs setlease with i_lock held to
1005 	 * protect *lease from going away.
1006 	 */
1007 	struct inode *inode = file_inode(file);
1008 	struct cifsFileInfo *cfile = file->private_data;
1009 
1010 	if (!(S_ISREG(inode->i_mode)))
1011 		return -EINVAL;
1012 
1013 	/* Check if file is oplocked if this is request for new lease */
1014 	if (arg == F_UNLCK ||
1015 	    ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1016 	    ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1017 		return generic_setlease(file, arg, lease, priv);
1018 	else if (tlink_tcon(cfile->tlink)->local_lease &&
1019 		 !CIFS_CACHE_READ(CIFS_I(inode)))
1020 		/*
1021 		 * If the server claims to support oplock on this file, then we
1022 		 * still need to check oplock even if the local_lease mount
1023 		 * option is set, but there are servers which do not support
1024 		 * oplock for which this mount option may be useful if the user
1025 		 * knows that the file won't be changed on the server by anyone
1026 		 * else.
1027 		 */
1028 		return generic_setlease(file, arg, lease, priv);
1029 	else
1030 		return -EAGAIN;
1031 }
1032 
1033 struct file_system_type cifs_fs_type = {
1034 	.owner = THIS_MODULE,
1035 	.name = "cifs",
1036 	.mount = cifs_do_mount,
1037 	.kill_sb = cifs_kill_sb,
1038 	.fs_flags = FS_RENAME_DOES_D_MOVE,
1039 };
1040 MODULE_ALIAS_FS("cifs");
1041 
1042 struct file_system_type smb3_fs_type = {
1043 	.owner = THIS_MODULE,
1044 	.name = "smb3",
1045 	.mount = smb3_do_mount,
1046 	.kill_sb = cifs_kill_sb,
1047 	.fs_flags = FS_RENAME_DOES_D_MOVE,
1048 };
1049 MODULE_ALIAS_FS("smb3");
1050 MODULE_ALIAS("smb3");
1051 
1052 const struct inode_operations cifs_dir_inode_ops = {
1053 	.create = cifs_create,
1054 	.atomic_open = cifs_atomic_open,
1055 	.lookup = cifs_lookup,
1056 	.getattr = cifs_getattr,
1057 	.unlink = cifs_unlink,
1058 	.link = cifs_hardlink,
1059 	.mkdir = cifs_mkdir,
1060 	.rmdir = cifs_rmdir,
1061 	.rename = cifs_rename2,
1062 	.permission = cifs_permission,
1063 	.setattr = cifs_setattr,
1064 	.symlink = cifs_symlink,
1065 	.mknod   = cifs_mknod,
1066 	.listxattr = cifs_listxattr,
1067 };
1068 
1069 const struct inode_operations cifs_file_inode_ops = {
1070 	.setattr = cifs_setattr,
1071 	.getattr = cifs_getattr,
1072 	.permission = cifs_permission,
1073 	.listxattr = cifs_listxattr,
1074 	.fiemap = cifs_fiemap,
1075 };
1076 
1077 const struct inode_operations cifs_symlink_inode_ops = {
1078 	.get_link = cifs_get_link,
1079 	.setattr = cifs_setattr,
1080 	.permission = cifs_permission,
1081 	.listxattr = cifs_listxattr,
1082 };
1083 
cifs_remap_file_range(struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,loff_t len,unsigned int remap_flags)1084 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1085 		struct file *dst_file, loff_t destoff, loff_t len,
1086 		unsigned int remap_flags)
1087 {
1088 	struct inode *src_inode = file_inode(src_file);
1089 	struct inode *target_inode = file_inode(dst_file);
1090 	struct cifsFileInfo *smb_file_src = src_file->private_data;
1091 	struct cifsFileInfo *smb_file_target;
1092 	struct cifs_tcon *target_tcon;
1093 	unsigned int xid;
1094 	int rc;
1095 
1096 	if (remap_flags & REMAP_FILE_DEDUP)
1097 		return -EOPNOTSUPP;
1098 	if (remap_flags & ~REMAP_FILE_ADVISORY)
1099 		return -EINVAL;
1100 
1101 	cifs_dbg(FYI, "clone range\n");
1102 
1103 	xid = get_xid();
1104 
1105 	if (!src_file->private_data || !dst_file->private_data) {
1106 		rc = -EBADF;
1107 		cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1108 		goto out;
1109 	}
1110 
1111 	smb_file_target = dst_file->private_data;
1112 	target_tcon = tlink_tcon(smb_file_target->tlink);
1113 
1114 	/*
1115 	 * Note: cifs case is easier than btrfs since server responsible for
1116 	 * checks for proper open modes and file type and if it wants
1117 	 * server could even support copy of range where source = target
1118 	 */
1119 	lock_two_nondirectories(target_inode, src_inode);
1120 
1121 	if (len == 0)
1122 		len = src_inode->i_size - off;
1123 
1124 	cifs_dbg(FYI, "about to flush pages\n");
1125 	/* should we flush first and last page first */
1126 	truncate_inode_pages_range(&target_inode->i_data, destoff,
1127 				   PAGE_ALIGN(destoff + len)-1);
1128 
1129 	if (target_tcon->ses->server->ops->duplicate_extents)
1130 		rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1131 			smb_file_src, smb_file_target, off, len, destoff);
1132 	else
1133 		rc = -EOPNOTSUPP;
1134 
1135 	/* force revalidate of size and timestamps of target file now
1136 	   that target is updated on the server */
1137 	CIFS_I(target_inode)->time = 0;
1138 	/* although unlocking in the reverse order from locking is not
1139 	   strictly necessary here it is a little cleaner to be consistent */
1140 	unlock_two_nondirectories(src_inode, target_inode);
1141 out:
1142 	free_xid(xid);
1143 	return rc < 0 ? rc : len;
1144 }
1145 
cifs_file_copychunk_range(unsigned int xid,struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,size_t len,unsigned int flags)1146 ssize_t cifs_file_copychunk_range(unsigned int xid,
1147 				struct file *src_file, loff_t off,
1148 				struct file *dst_file, loff_t destoff,
1149 				size_t len, unsigned int flags)
1150 {
1151 	struct inode *src_inode = file_inode(src_file);
1152 	struct inode *target_inode = file_inode(dst_file);
1153 	struct cifsFileInfo *smb_file_src;
1154 	struct cifsFileInfo *smb_file_target;
1155 	struct cifs_tcon *src_tcon;
1156 	struct cifs_tcon *target_tcon;
1157 	ssize_t rc;
1158 
1159 	cifs_dbg(FYI, "copychunk range\n");
1160 
1161 	if (!src_file->private_data || !dst_file->private_data) {
1162 		rc = -EBADF;
1163 		cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1164 		goto out;
1165 	}
1166 
1167 	rc = -EXDEV;
1168 	smb_file_target = dst_file->private_data;
1169 	smb_file_src = src_file->private_data;
1170 	src_tcon = tlink_tcon(smb_file_src->tlink);
1171 	target_tcon = tlink_tcon(smb_file_target->tlink);
1172 
1173 	if (src_tcon->ses != target_tcon->ses) {
1174 		cifs_dbg(VFS, "source and target of copy not on same server\n");
1175 		goto out;
1176 	}
1177 
1178 	rc = -EOPNOTSUPP;
1179 	if (!target_tcon->ses->server->ops->copychunk_range)
1180 		goto out;
1181 
1182 	/*
1183 	 * Note: cifs case is easier than btrfs since server responsible for
1184 	 * checks for proper open modes and file type and if it wants
1185 	 * server could even support copy of range where source = target
1186 	 */
1187 	lock_two_nondirectories(target_inode, src_inode);
1188 
1189 	cifs_dbg(FYI, "about to flush pages\n");
1190 	/* should we flush first and last page first */
1191 	truncate_inode_pages(&target_inode->i_data, 0);
1192 
1193 	rc = file_modified(dst_file);
1194 	if (!rc)
1195 		rc = target_tcon->ses->server->ops->copychunk_range(xid,
1196 			smb_file_src, smb_file_target, off, len, destoff);
1197 
1198 	file_accessed(src_file);
1199 
1200 	/* force revalidate of size and timestamps of target file now
1201 	 * that target is updated on the server
1202 	 */
1203 	CIFS_I(target_inode)->time = 0;
1204 	/* although unlocking in the reverse order from locking is not
1205 	 * strictly necessary here it is a little cleaner to be consistent
1206 	 */
1207 	unlock_two_nondirectories(src_inode, target_inode);
1208 
1209 out:
1210 	return rc;
1211 }
1212 
1213 /*
1214  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1215  * is a dummy operation.
1216  */
cifs_dir_fsync(struct file * file,loff_t start,loff_t end,int datasync)1217 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1218 {
1219 	cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1220 		 file, datasync);
1221 
1222 	return 0;
1223 }
1224 
cifs_copy_file_range(struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,size_t len,unsigned int flags)1225 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1226 				struct file *dst_file, loff_t destoff,
1227 				size_t len, unsigned int flags)
1228 {
1229 	unsigned int xid = get_xid();
1230 	ssize_t rc;
1231 	struct cifsFileInfo *cfile = dst_file->private_data;
1232 
1233 	if (cfile->swapfile) {
1234 		rc = -EOPNOTSUPP;
1235 		free_xid(xid);
1236 		return rc;
1237 	}
1238 
1239 	rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1240 					len, flags);
1241 	free_xid(xid);
1242 
1243 	if (rc == -EOPNOTSUPP || rc == -EXDEV)
1244 		rc = generic_copy_file_range(src_file, off, dst_file,
1245 					     destoff, len, flags);
1246 	return rc;
1247 }
1248 
1249 const struct file_operations cifs_file_ops = {
1250 	.read_iter = cifs_loose_read_iter,
1251 	.write_iter = cifs_file_write_iter,
1252 	.open = cifs_open,
1253 	.release = cifs_close,
1254 	.lock = cifs_lock,
1255 	.flock = cifs_flock,
1256 	.fsync = cifs_fsync,
1257 	.flush = cifs_flush,
1258 	.mmap  = cifs_file_mmap,
1259 	.splice_read = generic_file_splice_read,
1260 	.splice_write = iter_file_splice_write,
1261 	.llseek = cifs_llseek,
1262 	.unlocked_ioctl	= cifs_ioctl,
1263 	.copy_file_range = cifs_copy_file_range,
1264 	.remap_file_range = cifs_remap_file_range,
1265 	.setlease = cifs_setlease,
1266 	.fallocate = cifs_fallocate,
1267 };
1268 
1269 const struct file_operations cifs_file_strict_ops = {
1270 	.read_iter = cifs_strict_readv,
1271 	.write_iter = cifs_strict_writev,
1272 	.open = cifs_open,
1273 	.release = cifs_close,
1274 	.lock = cifs_lock,
1275 	.flock = cifs_flock,
1276 	.fsync = cifs_strict_fsync,
1277 	.flush = cifs_flush,
1278 	.mmap = cifs_file_strict_mmap,
1279 	.splice_read = generic_file_splice_read,
1280 	.splice_write = iter_file_splice_write,
1281 	.llseek = cifs_llseek,
1282 	.unlocked_ioctl	= cifs_ioctl,
1283 	.copy_file_range = cifs_copy_file_range,
1284 	.remap_file_range = cifs_remap_file_range,
1285 	.setlease = cifs_setlease,
1286 	.fallocate = cifs_fallocate,
1287 };
1288 
1289 const struct file_operations cifs_file_direct_ops = {
1290 	.read_iter = cifs_direct_readv,
1291 	.write_iter = cifs_direct_writev,
1292 	.open = cifs_open,
1293 	.release = cifs_close,
1294 	.lock = cifs_lock,
1295 	.flock = cifs_flock,
1296 	.fsync = cifs_fsync,
1297 	.flush = cifs_flush,
1298 	.mmap = cifs_file_mmap,
1299 	.splice_read = generic_file_splice_read,
1300 	.splice_write = iter_file_splice_write,
1301 	.unlocked_ioctl  = cifs_ioctl,
1302 	.copy_file_range = cifs_copy_file_range,
1303 	.remap_file_range = cifs_remap_file_range,
1304 	.llseek = cifs_llseek,
1305 	.setlease = cifs_setlease,
1306 	.fallocate = cifs_fallocate,
1307 };
1308 
1309 const struct file_operations cifs_file_nobrl_ops = {
1310 	.read_iter = cifs_loose_read_iter,
1311 	.write_iter = cifs_file_write_iter,
1312 	.open = cifs_open,
1313 	.release = cifs_close,
1314 	.fsync = cifs_fsync,
1315 	.flush = cifs_flush,
1316 	.mmap  = cifs_file_mmap,
1317 	.splice_read = generic_file_splice_read,
1318 	.splice_write = iter_file_splice_write,
1319 	.llseek = cifs_llseek,
1320 	.unlocked_ioctl	= cifs_ioctl,
1321 	.copy_file_range = cifs_copy_file_range,
1322 	.remap_file_range = cifs_remap_file_range,
1323 	.setlease = cifs_setlease,
1324 	.fallocate = cifs_fallocate,
1325 };
1326 
1327 const struct file_operations cifs_file_strict_nobrl_ops = {
1328 	.read_iter = cifs_strict_readv,
1329 	.write_iter = cifs_strict_writev,
1330 	.open = cifs_open,
1331 	.release = cifs_close,
1332 	.fsync = cifs_strict_fsync,
1333 	.flush = cifs_flush,
1334 	.mmap = cifs_file_strict_mmap,
1335 	.splice_read = generic_file_splice_read,
1336 	.splice_write = iter_file_splice_write,
1337 	.llseek = cifs_llseek,
1338 	.unlocked_ioctl	= cifs_ioctl,
1339 	.copy_file_range = cifs_copy_file_range,
1340 	.remap_file_range = cifs_remap_file_range,
1341 	.setlease = cifs_setlease,
1342 	.fallocate = cifs_fallocate,
1343 };
1344 
1345 const struct file_operations cifs_file_direct_nobrl_ops = {
1346 	.read_iter = cifs_direct_readv,
1347 	.write_iter = cifs_direct_writev,
1348 	.open = cifs_open,
1349 	.release = cifs_close,
1350 	.fsync = cifs_fsync,
1351 	.flush = cifs_flush,
1352 	.mmap = cifs_file_mmap,
1353 	.splice_read = generic_file_splice_read,
1354 	.splice_write = iter_file_splice_write,
1355 	.unlocked_ioctl  = cifs_ioctl,
1356 	.copy_file_range = cifs_copy_file_range,
1357 	.remap_file_range = cifs_remap_file_range,
1358 	.llseek = cifs_llseek,
1359 	.setlease = cifs_setlease,
1360 	.fallocate = cifs_fallocate,
1361 };
1362 
1363 const struct file_operations cifs_dir_ops = {
1364 	.iterate_shared = cifs_readdir,
1365 	.release = cifs_closedir,
1366 	.read    = generic_read_dir,
1367 	.unlocked_ioctl  = cifs_ioctl,
1368 	.copy_file_range = cifs_copy_file_range,
1369 	.remap_file_range = cifs_remap_file_range,
1370 	.llseek = generic_file_llseek,
1371 	.fsync = cifs_dir_fsync,
1372 };
1373 
1374 static void
cifs_init_once(void * inode)1375 cifs_init_once(void *inode)
1376 {
1377 	struct cifsInodeInfo *cifsi = inode;
1378 
1379 	inode_init_once(&cifsi->vfs_inode);
1380 	init_rwsem(&cifsi->lock_sem);
1381 }
1382 
1383 static int __init
cifs_init_inodecache(void)1384 cifs_init_inodecache(void)
1385 {
1386 	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1387 					      sizeof(struct cifsInodeInfo),
1388 					      0, (SLAB_RECLAIM_ACCOUNT|
1389 						SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1390 					      cifs_init_once);
1391 	if (cifs_inode_cachep == NULL)
1392 		return -ENOMEM;
1393 
1394 	return 0;
1395 }
1396 
1397 static void
cifs_destroy_inodecache(void)1398 cifs_destroy_inodecache(void)
1399 {
1400 	/*
1401 	 * Make sure all delayed rcu free inodes are flushed before we
1402 	 * destroy cache.
1403 	 */
1404 	rcu_barrier();
1405 	kmem_cache_destroy(cifs_inode_cachep);
1406 }
1407 
1408 static int
cifs_init_request_bufs(void)1409 cifs_init_request_bufs(void)
1410 {
1411 	/*
1412 	 * SMB2 maximum header size is bigger than CIFS one - no problems to
1413 	 * allocate some more bytes for CIFS.
1414 	 */
1415 	size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1416 
1417 	if (CIFSMaxBufSize < 8192) {
1418 	/* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1419 	Unicode path name has to fit in any SMB/CIFS path based frames */
1420 		CIFSMaxBufSize = 8192;
1421 	} else if (CIFSMaxBufSize > 1024*127) {
1422 		CIFSMaxBufSize = 1024 * 127;
1423 	} else {
1424 		CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1425 	}
1426 /*
1427 	cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1428 		 CIFSMaxBufSize, CIFSMaxBufSize);
1429 */
1430 	cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1431 					    CIFSMaxBufSize + max_hdr_size, 0,
1432 					    SLAB_HWCACHE_ALIGN, 0,
1433 					    CIFSMaxBufSize + max_hdr_size,
1434 					    NULL);
1435 	if (cifs_req_cachep == NULL)
1436 		return -ENOMEM;
1437 
1438 	if (cifs_min_rcv < 1)
1439 		cifs_min_rcv = 1;
1440 	else if (cifs_min_rcv > 64) {
1441 		cifs_min_rcv = 64;
1442 		cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1443 	}
1444 
1445 	cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1446 						  cifs_req_cachep);
1447 
1448 	if (cifs_req_poolp == NULL) {
1449 		kmem_cache_destroy(cifs_req_cachep);
1450 		return -ENOMEM;
1451 	}
1452 	/* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1453 	almost all handle based requests (but not write response, nor is it
1454 	sufficient for path based requests).  A smaller size would have
1455 	been more efficient (compacting multiple slab items on one 4k page)
1456 	for the case in which debug was on, but this larger size allows
1457 	more SMBs to use small buffer alloc and is still much more
1458 	efficient to alloc 1 per page off the slab compared to 17K (5page)
1459 	alloc of large cifs buffers even when page debugging is on */
1460 	cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1461 			MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1462 			0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1463 	if (cifs_sm_req_cachep == NULL) {
1464 		mempool_destroy(cifs_req_poolp);
1465 		kmem_cache_destroy(cifs_req_cachep);
1466 		return -ENOMEM;
1467 	}
1468 
1469 	if (cifs_min_small < 2)
1470 		cifs_min_small = 2;
1471 	else if (cifs_min_small > 256) {
1472 		cifs_min_small = 256;
1473 		cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1474 	}
1475 
1476 	cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1477 						     cifs_sm_req_cachep);
1478 
1479 	if (cifs_sm_req_poolp == NULL) {
1480 		mempool_destroy(cifs_req_poolp);
1481 		kmem_cache_destroy(cifs_req_cachep);
1482 		kmem_cache_destroy(cifs_sm_req_cachep);
1483 		return -ENOMEM;
1484 	}
1485 
1486 	return 0;
1487 }
1488 
1489 static void
cifs_destroy_request_bufs(void)1490 cifs_destroy_request_bufs(void)
1491 {
1492 	mempool_destroy(cifs_req_poolp);
1493 	kmem_cache_destroy(cifs_req_cachep);
1494 	mempool_destroy(cifs_sm_req_poolp);
1495 	kmem_cache_destroy(cifs_sm_req_cachep);
1496 }
1497 
1498 static int
cifs_init_mids(void)1499 cifs_init_mids(void)
1500 {
1501 	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1502 					    sizeof(struct mid_q_entry), 0,
1503 					    SLAB_HWCACHE_ALIGN, NULL);
1504 	if (cifs_mid_cachep == NULL)
1505 		return -ENOMEM;
1506 
1507 	/* 3 is a reasonable minimum number of simultaneous operations */
1508 	cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1509 	if (cifs_mid_poolp == NULL) {
1510 		kmem_cache_destroy(cifs_mid_cachep);
1511 		return -ENOMEM;
1512 	}
1513 
1514 	return 0;
1515 }
1516 
1517 static void
cifs_destroy_mids(void)1518 cifs_destroy_mids(void)
1519 {
1520 	mempool_destroy(cifs_mid_poolp);
1521 	kmem_cache_destroy(cifs_mid_cachep);
1522 }
1523 
1524 static int __init
init_cifs(void)1525 init_cifs(void)
1526 {
1527 	int rc = 0;
1528 	cifs_proc_init();
1529 	INIT_LIST_HEAD(&cifs_tcp_ses_list);
1530 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1531 	INIT_LIST_HEAD(&GlobalDnotifyReqList);
1532 	INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1533 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1534 /*
1535  *  Initialize Global counters
1536  */
1537 	atomic_set(&sesInfoAllocCount, 0);
1538 	atomic_set(&tconInfoAllocCount, 0);
1539 	atomic_set(&tcpSesAllocCount, 0);
1540 	atomic_set(&tcpSesReconnectCount, 0);
1541 	atomic_set(&tconInfoReconnectCount, 0);
1542 
1543 	atomic_set(&bufAllocCount, 0);
1544 	atomic_set(&smBufAllocCount, 0);
1545 #ifdef CONFIG_CIFS_STATS2
1546 	atomic_set(&totBufAllocCount, 0);
1547 	atomic_set(&totSmBufAllocCount, 0);
1548 	if (slow_rsp_threshold < 1)
1549 		cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1550 	else if (slow_rsp_threshold > 32767)
1551 		cifs_dbg(VFS,
1552 		       "slow response threshold set higher than recommended (0 to 32767)\n");
1553 #endif /* CONFIG_CIFS_STATS2 */
1554 
1555 	atomic_set(&midCount, 0);
1556 	GlobalCurrentXid = 0;
1557 	GlobalTotalActiveXid = 0;
1558 	GlobalMaxActiveXid = 0;
1559 	spin_lock_init(&cifs_tcp_ses_lock);
1560 	spin_lock_init(&GlobalMid_Lock);
1561 
1562 	cifs_lock_secret = get_random_u32();
1563 
1564 	if (cifs_max_pending < 2) {
1565 		cifs_max_pending = 2;
1566 		cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1567 	} else if (cifs_max_pending > CIFS_MAX_REQ) {
1568 		cifs_max_pending = CIFS_MAX_REQ;
1569 		cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1570 			 CIFS_MAX_REQ);
1571 	}
1572 
1573 	cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1574 	if (!cifsiod_wq) {
1575 		rc = -ENOMEM;
1576 		goto out_clean_proc;
1577 	}
1578 
1579 	/*
1580 	 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1581 	 * so that we don't launch too many worker threads but
1582 	 * Documentation/core-api/workqueue.rst recommends setting it to 0
1583 	 */
1584 
1585 	/* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1586 	decrypt_wq = alloc_workqueue("smb3decryptd",
1587 				     WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1588 	if (!decrypt_wq) {
1589 		rc = -ENOMEM;
1590 		goto out_destroy_cifsiod_wq;
1591 	}
1592 
1593 	fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1594 				     WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1595 	if (!fileinfo_put_wq) {
1596 		rc = -ENOMEM;
1597 		goto out_destroy_decrypt_wq;
1598 	}
1599 
1600 	cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1601 					 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1602 	if (!cifsoplockd_wq) {
1603 		rc = -ENOMEM;
1604 		goto out_destroy_fileinfo_put_wq;
1605 	}
1606 
1607 	rc = cifs_fscache_register();
1608 	if (rc)
1609 		goto out_destroy_cifsoplockd_wq;
1610 
1611 	rc = cifs_init_inodecache();
1612 	if (rc)
1613 		goto out_unreg_fscache;
1614 
1615 	rc = cifs_init_mids();
1616 	if (rc)
1617 		goto out_destroy_inodecache;
1618 
1619 	rc = cifs_init_request_bufs();
1620 	if (rc)
1621 		goto out_destroy_mids;
1622 
1623 #ifdef CONFIG_CIFS_DFS_UPCALL
1624 	rc = dfs_cache_init();
1625 	if (rc)
1626 		goto out_destroy_request_bufs;
1627 #endif /* CONFIG_CIFS_DFS_UPCALL */
1628 #ifdef CONFIG_CIFS_UPCALL
1629 	rc = init_cifs_spnego();
1630 	if (rc)
1631 		goto out_destroy_dfs_cache;
1632 #endif /* CONFIG_CIFS_UPCALL */
1633 
1634 	rc = init_cifs_idmap();
1635 	if (rc)
1636 		goto out_register_key_type;
1637 
1638 	rc = register_filesystem(&cifs_fs_type);
1639 	if (rc)
1640 		goto out_init_cifs_idmap;
1641 
1642 	rc = register_filesystem(&smb3_fs_type);
1643 	if (rc) {
1644 		unregister_filesystem(&cifs_fs_type);
1645 		goto out_init_cifs_idmap;
1646 	}
1647 
1648 	return 0;
1649 
1650 out_init_cifs_idmap:
1651 	exit_cifs_idmap();
1652 out_register_key_type:
1653 #ifdef CONFIG_CIFS_UPCALL
1654 	exit_cifs_spnego();
1655 out_destroy_dfs_cache:
1656 #endif
1657 #ifdef CONFIG_CIFS_DFS_UPCALL
1658 	dfs_cache_destroy();
1659 out_destroy_request_bufs:
1660 #endif
1661 	cifs_destroy_request_bufs();
1662 out_destroy_mids:
1663 	cifs_destroy_mids();
1664 out_destroy_inodecache:
1665 	cifs_destroy_inodecache();
1666 out_unreg_fscache:
1667 	cifs_fscache_unregister();
1668 out_destroy_cifsoplockd_wq:
1669 	destroy_workqueue(cifsoplockd_wq);
1670 out_destroy_fileinfo_put_wq:
1671 	destroy_workqueue(fileinfo_put_wq);
1672 out_destroy_decrypt_wq:
1673 	destroy_workqueue(decrypt_wq);
1674 out_destroy_cifsiod_wq:
1675 	destroy_workqueue(cifsiod_wq);
1676 out_clean_proc:
1677 	cifs_proc_clean();
1678 	return rc;
1679 }
1680 
1681 static void __exit
exit_cifs(void)1682 exit_cifs(void)
1683 {
1684 	cifs_dbg(NOISY, "exit_smb3\n");
1685 	unregister_filesystem(&cifs_fs_type);
1686 	unregister_filesystem(&smb3_fs_type);
1687 	cifs_dfs_release_automount_timer();
1688 	exit_cifs_idmap();
1689 #ifdef CONFIG_CIFS_UPCALL
1690 	exit_cifs_spnego();
1691 #endif
1692 #ifdef CONFIG_CIFS_DFS_UPCALL
1693 	dfs_cache_destroy();
1694 #endif
1695 	cifs_destroy_request_bufs();
1696 	cifs_destroy_mids();
1697 	cifs_destroy_inodecache();
1698 	cifs_fscache_unregister();
1699 	destroy_workqueue(cifsoplockd_wq);
1700 	destroy_workqueue(decrypt_wq);
1701 	destroy_workqueue(fileinfo_put_wq);
1702 	destroy_workqueue(cifsiod_wq);
1703 	cifs_proc_clean();
1704 }
1705 
1706 MODULE_AUTHOR("Steve French");
1707 MODULE_LICENSE("GPL");	/* combination of LGPL + GPL source behaves as GPL */
1708 MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
1709 MODULE_DESCRIPTION
1710 	("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1711 	"also older servers complying with the SNIA CIFS Specification)");
1712 MODULE_VERSION(CIFS_VERSION);
1713 MODULE_SOFTDEP("ecb");
1714 MODULE_SOFTDEP("hmac");
1715 MODULE_SOFTDEP("md4");
1716 MODULE_SOFTDEP("md5");
1717 MODULE_SOFTDEP("nls");
1718 MODULE_SOFTDEP("aes");
1719 MODULE_SOFTDEP("cmac");
1720 MODULE_SOFTDEP("sha256");
1721 MODULE_SOFTDEP("sha512");
1722 MODULE_SOFTDEP("aead2");
1723 MODULE_SOFTDEP("ccm");
1724 MODULE_SOFTDEP("gcm");
1725 module_init(init_cifs)
1726 module_exit(exit_cifs)
1727