1 // SPDX-License-Identifier: LGPL-2.1
5 * Copyright (C) International Business Machines Corp., 2002,2008
6 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Common Internet FileSystem (CIFS) client
12 /* Note that BB means BUGBUG (ie something to fix eventually) */
14 #include <linux/module.h>
16 #include <linux/mount.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/list.h>
20 #include <linux/seq_file.h>
21 #include <linux/vfs.h>
22 #include <linux/mempool.h>
23 #include <linux/delay.h>
24 #include <linux/kthread.h>
25 #include <linux/freezer.h>
26 #include <linux/namei.h>
27 #include <linux/random.h>
28 #include <linux/uuid.h>
29 #include <linux/xattr.h>
33 #define DECLARE_GLOBALS_HERE
35 #include "cifsproto.h"
36 #include "cifs_debug.h"
37 #include "cifs_fs_sb.h"
39 #include <linux/key-type.h>
40 #include "cifs_spnego.h"
43 #ifdef CONFIG_CIFS_DFS_UPCALL
44 #include "dfs_cache.h"
46 #ifdef CONFIG_CIFS_SWN_UPCALL
49 #include "fs_context.h"
52 * DOS dates from 1980/1/1 through 2107/12/31
53 * Protocol specifications indicate the range should be to 119, which
54 * limits maximum year to 2099. But this range has not been checked.
56 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
57 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
58 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
62 bool enable_oplocks = true;
63 bool linuxExtEnabled = true;
64 bool lookupCacheEnabled = true;
65 bool disable_legacy_dialects; /* false by default */
66 bool enable_gcm_256 = true;
67 bool require_gcm_256; /* false by default */
68 unsigned int global_secflags = CIFSSEC_DEF;
69 /* unsigned int ntlmv2_support = 0; */
70 unsigned int sign_CIFS_PDUs = 1;
71 static const struct super_operations cifs_super_ops;
72 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
73 module_param(CIFSMaxBufSize, uint, 0444);
74 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
76 "Default: 16384 Range: 8192 to 130048");
77 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
78 module_param(cifs_min_rcv, uint, 0444);
79 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
81 unsigned int cifs_min_small = 30;
82 module_param(cifs_min_small, uint, 0444);
83 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
85 unsigned int cifs_max_pending = CIFS_MAX_REQ;
86 module_param(cifs_max_pending, uint, 0444);
87 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
88 "CIFS/SMB1 dialect (N/A for SMB3) "
89 "Default: 32767 Range: 2 to 32767.");
90 #ifdef CONFIG_CIFS_STATS2
91 unsigned int slow_rsp_threshold = 1;
92 module_param(slow_rsp_threshold, uint, 0644);
93 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
94 "before logging that a response is delayed. "
95 "Default: 1 (if set to 0 disables msg).");
98 module_param(enable_oplocks, bool, 0644);
99 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
101 module_param(enable_gcm_256, bool, 0644);
102 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
104 module_param(require_gcm_256, bool, 0644);
105 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
107 module_param(disable_legacy_dialects, bool, 0644);
108 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
109 "helpful to restrict the ability to "
110 "override the default dialects (SMB2.1, "
111 "SMB3 and SMB3.02) on mount with old "
112 "dialects (CIFS/SMB1 and SMB2) since "
113 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
114 " and less secure. Default: n/N/0");
116 extern mempool_t *cifs_sm_req_poolp;
117 extern mempool_t *cifs_req_poolp;
118 extern mempool_t *cifs_mid_poolp;
120 struct workqueue_struct *cifsiod_wq;
121 struct workqueue_struct *decrypt_wq;
122 struct workqueue_struct *fileinfo_put_wq;
123 struct workqueue_struct *cifsoplockd_wq;
124 struct workqueue_struct *deferredclose_wq;
125 __u32 cifs_lock_secret;
128 * Bumps refcount for cifs super block.
129 * Note that it should be only called if a referece to VFS super block is
130 * already held, e.g. in open-type syscalls context. Otherwise it can race with
131 * atomic_dec_and_test in deactivate_locked_super.
134 cifs_sb_active(struct super_block *sb)
136 struct cifs_sb_info *server = CIFS_SB(sb);
138 if (atomic_inc_return(&server->active) == 1)
139 atomic_inc(&sb->s_active);
143 cifs_sb_deactive(struct super_block *sb)
145 struct cifs_sb_info *server = CIFS_SB(sb);
147 if (atomic_dec_and_test(&server->active))
148 deactivate_super(sb);
152 cifs_read_super(struct super_block *sb)
155 struct cifs_sb_info *cifs_sb;
156 struct cifs_tcon *tcon;
157 struct timespec64 ts;
160 cifs_sb = CIFS_SB(sb);
161 tcon = cifs_sb_master_tcon(cifs_sb);
163 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
164 sb->s_flags |= SB_POSIXACL;
166 if (tcon->snapshot_time)
167 sb->s_flags |= SB_RDONLY;
169 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
170 sb->s_maxbytes = MAX_LFS_FILESIZE;
172 sb->s_maxbytes = MAX_NON_LFS;
175 * Some very old servers like DOS and OS/2 used 2 second granularity
176 * (while all current servers use 100ns granularity - see MS-DTYP)
177 * but 1 second is the maximum allowed granularity for the VFS
178 * so for old servers set time granularity to 1 second while for
179 * everything else (current servers) set it to 100ns.
181 if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
182 ((tcon->ses->capabilities &
183 tcon->ses->server->vals->cap_nt_find) == 0) &&
185 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
186 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
187 sb->s_time_min = ts.tv_sec;
188 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
189 cpu_to_le16(SMB_TIME_MAX), 0);
190 sb->s_time_max = ts.tv_sec;
193 * Almost every server, including all SMB2+, uses DCE TIME
194 * ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC
196 sb->s_time_gran = 100;
197 ts = cifs_NTtimeToUnix(0);
198 sb->s_time_min = ts.tv_sec;
199 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
200 sb->s_time_max = ts.tv_sec;
203 sb->s_magic = CIFS_MAGIC_NUMBER;
204 sb->s_op = &cifs_super_ops;
205 sb->s_xattr = cifs_xattr_handlers;
206 rc = super_setup_bdi(sb);
209 /* tune readahead according to rsize if readahead size not set on mount */
210 if (cifs_sb->ctx->rasize)
211 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
213 sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
215 sb->s_blocksize = CIFS_MAX_MSGSIZE;
216 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
217 inode = cifs_root_iget(sb);
225 sb->s_d_op = &cifs_ci_dentry_ops;
227 sb->s_d_op = &cifs_dentry_ops;
229 sb->s_root = d_make_root(inode);
235 #ifdef CONFIG_CIFS_NFSD_EXPORT
236 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
237 cifs_dbg(FYI, "export ops supported\n");
238 sb->s_export_op = &cifs_export_ops;
240 #endif /* CONFIG_CIFS_NFSD_EXPORT */
245 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
249 static void cifs_kill_sb(struct super_block *sb)
251 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
252 struct cifs_tcon *tcon;
253 struct cached_fid *cfid;
256 * We ned to release all dentries for the cached directories
257 * before we kill the sb.
261 cifs_sb->root = NULL;
263 tcon = cifs_sb_master_tcon(cifs_sb);
266 mutex_lock(&cfid->fid_mutex);
272 mutex_unlock(&cfid->fid_mutex);
276 cifs_umount(cifs_sb);
280 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
282 struct super_block *sb = dentry->d_sb;
283 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
284 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
285 struct TCP_Server_Info *server = tcon->ses->server;
291 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
293 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
295 buf->f_namelen = PATH_MAX;
297 buf->f_fsid.val[0] = tcon->vol_serial_number;
298 /* are using part of create time for more randomness, see man statfs */
299 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
301 buf->f_files = 0; /* undefined */
302 buf->f_ffree = 0; /* unlimited */
304 if (server->ops->queryfs)
305 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
311 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
313 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
314 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
315 struct TCP_Server_Info *server = tcon->ses->server;
317 if (server->ops->fallocate)
318 return server->ops->fallocate(file, tcon, mode, off, len);
323 static int cifs_permission(struct user_namespace *mnt_userns,
324 struct inode *inode, int mask)
326 struct cifs_sb_info *cifs_sb;
328 cifs_sb = CIFS_SB(inode->i_sb);
330 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
331 if ((mask & MAY_EXEC) && !execute_ok(inode))
335 } else /* file mode might have been restricted at mount time
336 on the client (above and beyond ACL on servers) for
337 servers which do not support setting and viewing mode bits,
338 so allowing client to check permissions is useful */
339 return generic_permission(&init_user_ns, inode, mask);
342 static struct kmem_cache *cifs_inode_cachep;
343 static struct kmem_cache *cifs_req_cachep;
344 static struct kmem_cache *cifs_mid_cachep;
345 static struct kmem_cache *cifs_sm_req_cachep;
346 mempool_t *cifs_sm_req_poolp;
347 mempool_t *cifs_req_poolp;
348 mempool_t *cifs_mid_poolp;
350 static struct inode *
351 cifs_alloc_inode(struct super_block *sb)
353 struct cifsInodeInfo *cifs_inode;
354 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
357 cifs_inode->cifsAttrs = 0x20; /* default */
358 cifs_inode->time = 0;
360 * Until the file is open and we have gotten oplock info back from the
361 * server, can not assume caching of file data or metadata.
363 cifs_set_oplock_level(cifs_inode, 0);
364 cifs_inode->flags = 0;
365 spin_lock_init(&cifs_inode->writers_lock);
366 cifs_inode->writers = 0;
367 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
368 cifs_inode->server_eof = 0;
369 cifs_inode->uniqueid = 0;
370 cifs_inode->createtime = 0;
371 cifs_inode->epoch = 0;
372 spin_lock_init(&cifs_inode->open_file_lock);
373 generate_random_uuid(cifs_inode->lease_key);
376 * Can not set i_flags here - they get immediately overwritten to zero
379 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
380 INIT_LIST_HEAD(&cifs_inode->openFileList);
381 INIT_LIST_HEAD(&cifs_inode->llist);
382 INIT_LIST_HEAD(&cifs_inode->deferred_closes);
383 spin_lock_init(&cifs_inode->deferred_lock);
384 return &cifs_inode->vfs_inode;
388 cifs_free_inode(struct inode *inode)
390 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
394 cifs_evict_inode(struct inode *inode)
396 truncate_inode_pages_final(&inode->i_data);
398 cifs_fscache_release_inode_cookie(inode);
402 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
404 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
405 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
407 seq_puts(s, ",addr=");
409 switch (server->dstaddr.ss_family) {
411 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
414 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
415 if (sa6->sin6_scope_id)
416 seq_printf(s, "%%%u", sa6->sin6_scope_id);
419 seq_puts(s, "(unknown)");
422 seq_puts(s, ",rdma");
426 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
428 if (ses->sectype == Unspecified) {
429 if (ses->user_name == NULL)
430 seq_puts(s, ",sec=none");
434 seq_puts(s, ",sec=");
436 switch (ses->sectype) {
438 seq_puts(s, "lanman");
441 seq_puts(s, "ntlmv2");
450 seq_puts(s, "ntlmssp");
453 /* shouldn't ever happen */
454 seq_puts(s, "unknown");
461 if (ses->sectype == Kerberos)
462 seq_printf(s, ",cruid=%u",
463 from_kuid_munged(&init_user_ns, ses->cred_uid));
467 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
469 seq_puts(s, ",cache=");
471 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
472 seq_puts(s, "strict");
473 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
475 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
476 seq_puts(s, "singleclient"); /* assume only one client access */
477 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
478 seq_puts(s, "ro"); /* read only caching assumed */
480 seq_puts(s, "loose");
484 * cifs_show_devname() is used so we show the mount device name with correct
485 * format (e.g. forward slashes vs. back slashes) in /proc/mounts
487 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
489 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
490 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
495 convert_delimiter(devname, '/');
496 /* escape all spaces in share names */
497 seq_escape(m, devname, " \t");
504 * cifs_show_options() is for displaying mount options in /proc/mounts.
505 * Not all settable options are displayed but most of the important
509 cifs_show_options(struct seq_file *s, struct dentry *root)
511 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
512 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
513 struct sockaddr *srcaddr;
514 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
516 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
517 cifs_show_security(s, tcon->ses);
518 cifs_show_cache_flavor(s, cifs_sb);
521 seq_puts(s, ",nolease");
522 if (cifs_sb->ctx->multiuser)
523 seq_puts(s, ",multiuser");
524 else if (tcon->ses->user_name)
525 seq_show_option(s, "username", tcon->ses->user_name);
527 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
528 seq_show_option(s, "domain", tcon->ses->domainName);
530 if (srcaddr->sa_family != AF_UNSPEC) {
531 struct sockaddr_in *saddr4;
532 struct sockaddr_in6 *saddr6;
533 saddr4 = (struct sockaddr_in *)srcaddr;
534 saddr6 = (struct sockaddr_in6 *)srcaddr;
535 if (srcaddr->sa_family == AF_INET6)
536 seq_printf(s, ",srcaddr=%pI6c",
538 else if (srcaddr->sa_family == AF_INET)
539 seq_printf(s, ",srcaddr=%pI4",
540 &saddr4->sin_addr.s_addr);
542 seq_printf(s, ",srcaddr=BAD-AF:%i",
543 (int)(srcaddr->sa_family));
546 seq_printf(s, ",uid=%u",
547 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
548 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
549 seq_puts(s, ",forceuid");
551 seq_puts(s, ",noforceuid");
553 seq_printf(s, ",gid=%u",
554 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
555 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
556 seq_puts(s, ",forcegid");
558 seq_puts(s, ",noforcegid");
560 cifs_show_address(s, tcon->ses->server);
563 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
564 cifs_sb->ctx->file_mode,
565 cifs_sb->ctx->dir_mode);
566 if (cifs_sb->ctx->iocharset)
567 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
569 seq_puts(s, ",seal");
570 else if (tcon->ses->server->ignore_signature)
571 seq_puts(s, ",signloosely");
573 seq_puts(s, ",nocase");
575 seq_puts(s, ",nodelete");
576 if (tcon->local_lease)
577 seq_puts(s, ",locallease");
579 seq_puts(s, ",hard");
581 seq_puts(s, ",soft");
582 if (tcon->use_persistent)
583 seq_puts(s, ",persistenthandles");
584 else if (tcon->use_resilient)
585 seq_puts(s, ",resilienthandles");
586 if (tcon->posix_extensions)
587 seq_puts(s, ",posix");
588 else if (tcon->unix_ext)
589 seq_puts(s, ",unix");
591 seq_puts(s, ",nounix");
592 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
593 seq_puts(s, ",nodfs");
594 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
595 seq_puts(s, ",posixpaths");
596 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
597 seq_puts(s, ",setuids");
598 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
599 seq_puts(s, ",idsfromsid");
600 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
601 seq_puts(s, ",serverino");
602 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
603 seq_puts(s, ",rwpidforward");
604 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
605 seq_puts(s, ",forcemand");
606 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
607 seq_puts(s, ",nouser_xattr");
608 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
609 seq_puts(s, ",mapchars");
610 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
611 seq_puts(s, ",mapposix");
612 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
614 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
615 seq_puts(s, ",nobrl");
616 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
617 seq_puts(s, ",nohandlecache");
618 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
619 seq_puts(s, ",modefromsid");
620 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
621 seq_puts(s, ",cifsacl");
622 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
623 seq_puts(s, ",dynperm");
624 if (root->d_sb->s_flags & SB_POSIXACL)
626 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
627 seq_puts(s, ",mfsymlinks");
628 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
630 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
631 seq_puts(s, ",nostrictsync");
632 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
633 seq_puts(s, ",noperm");
634 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
635 seq_printf(s, ",backupuid=%u",
636 from_kuid_munged(&init_user_ns,
637 cifs_sb->ctx->backupuid));
638 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
639 seq_printf(s, ",backupgid=%u",
640 from_kgid_munged(&init_user_ns,
641 cifs_sb->ctx->backupgid));
643 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
644 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
645 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
646 if (cifs_sb->ctx->rasize)
647 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
648 if (tcon->ses->server->min_offload)
649 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
650 seq_printf(s, ",echo_interval=%lu",
651 tcon->ses->server->echo_interval / HZ);
653 /* Only display max_credits if it was overridden on mount */
654 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
655 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
657 if (tcon->snapshot_time)
658 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
659 if (tcon->handle_timeout)
660 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
663 * Display file and directory attribute timeout in seconds.
664 * If file and directory attribute timeout the same then actimeo
665 * was likely specified on mount
667 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
668 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
670 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
671 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
674 if (tcon->ses->chan_max > 1)
675 seq_printf(s, ",multichannel,max_channels=%zu",
676 tcon->ses->chan_max);
678 if (tcon->use_witness)
679 seq_puts(s, ",witness");
684 static void cifs_umount_begin(struct super_block *sb)
686 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
687 struct cifs_tcon *tcon;
692 tcon = cifs_sb_master_tcon(cifs_sb);
694 spin_lock(&cifs_tcp_ses_lock);
695 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
696 /* we have other mounts to same share or we have
697 already tried to force umount this and woken up
698 all waiting network requests, nothing to do */
699 spin_unlock(&cifs_tcp_ses_lock);
701 } else if (tcon->tc_count == 1)
702 tcon->tidStatus = CifsExiting;
703 spin_unlock(&cifs_tcp_ses_lock);
705 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
706 /* cancel_notify_requests(tcon); */
707 if (tcon->ses && tcon->ses->server) {
708 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
709 wake_up_all(&tcon->ses->server->request_q);
710 wake_up_all(&tcon->ses->server->response_q);
711 msleep(1); /* yield */
712 /* we have to kick the requests once more */
713 wake_up_all(&tcon->ses->server->response_q);
720 #ifdef CONFIG_CIFS_STATS2
721 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
728 static int cifs_drop_inode(struct inode *inode)
730 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
732 /* no serverino => unconditional eviction */
733 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
734 generic_drop_inode(inode);
737 static const struct super_operations cifs_super_ops = {
738 .statfs = cifs_statfs,
739 .alloc_inode = cifs_alloc_inode,
740 .free_inode = cifs_free_inode,
741 .drop_inode = cifs_drop_inode,
742 .evict_inode = cifs_evict_inode,
743 /* .show_path = cifs_show_path, */ /* Would we ever need show path? */
744 .show_devname = cifs_show_devname,
745 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
746 function unless later we add lazy close of inodes or unless the
747 kernel forgets to call us with the same number of releases (closes)
749 .show_options = cifs_show_options,
750 .umount_begin = cifs_umount_begin,
751 #ifdef CONFIG_CIFS_STATS2
752 .show_stats = cifs_show_stats,
757 * Get root dentry from superblock according to prefix path mount option.
758 * Return dentry with refcount + 1 on success and NULL otherwise.
760 static struct dentry *
761 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
763 struct dentry *dentry;
764 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
765 char *full_path = NULL;
769 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
770 return dget(sb->s_root);
772 full_path = cifs_build_path_to_root(ctx, cifs_sb,
773 cifs_sb_master_tcon(cifs_sb), 0);
774 if (full_path == NULL)
775 return ERR_PTR(-ENOMEM);
777 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
779 sep = CIFS_DIR_SEP(cifs_sb);
780 dentry = dget(sb->s_root);
784 struct inode *dir = d_inode(dentry);
785 struct dentry *child;
787 if (!S_ISDIR(dir->i_mode)) {
789 dentry = ERR_PTR(-ENOTDIR);
793 /* skip separators */
800 while (*s && *s != sep)
803 child = lookup_positive_unlocked(p, dentry, s - p);
806 } while (!IS_ERR(dentry));
811 static int cifs_set_super(struct super_block *sb, void *data)
813 struct cifs_mnt_data *mnt_data = data;
814 sb->s_fs_info = mnt_data->cifs_sb;
815 return set_anon_super(sb, NULL);
819 cifs_smb3_do_mount(struct file_system_type *fs_type,
820 int flags, struct smb3_fs_context *old_ctx)
823 struct super_block *sb;
824 struct cifs_sb_info *cifs_sb = NULL;
825 struct cifs_mnt_data mnt_data;
829 * Prints in Kernel / CIFS log the attempted mount operation
830 * If CIFS_DEBUG && cifs_FYI
833 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
835 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
837 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
838 if (cifs_sb == NULL) {
839 root = ERR_PTR(-ENOMEM);
843 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
845 root = ERR_PTR(-ENOMEM);
848 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
854 rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
860 rc = cifs_setup_cifs_sb(cifs_sb);
866 rc = cifs_mount(cifs_sb, cifs_sb->ctx);
868 if (!(flags & SB_SILENT))
869 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
875 mnt_data.ctx = cifs_sb->ctx;
876 mnt_data.cifs_sb = cifs_sb;
877 mnt_data.flags = flags;
879 /* BB should we make this contingent on mount parm? */
880 flags |= SB_NODIRATIME | SB_NOATIME;
882 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
885 cifs_umount(cifs_sb);
891 cifs_dbg(FYI, "Use existing superblock\n");
892 cifs_umount(cifs_sb);
895 rc = cifs_read_super(sb);
901 sb->s_flags |= SB_ACTIVE;
904 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
909 cifs_sb->root = dget(root);
911 cifs_dbg(FYI, "dentry root is: %p\n", root);
915 deactivate_locked_super(sb);
918 kfree(cifs_sb->prepath);
919 smb3_cleanup_fs_context(cifs_sb->ctx);
927 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
930 struct inode *inode = file_inode(iocb->ki_filp);
932 if (iocb->ki_filp->f_flags & O_DIRECT)
933 return cifs_user_readv(iocb, iter);
935 rc = cifs_revalidate_mapping(inode);
939 return generic_file_read_iter(iocb, iter);
942 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
944 struct inode *inode = file_inode(iocb->ki_filp);
945 struct cifsInodeInfo *cinode = CIFS_I(inode);
949 if (iocb->ki_filp->f_flags & O_DIRECT) {
950 written = cifs_user_writev(iocb, from);
951 if (written > 0 && CIFS_CACHE_READ(cinode)) {
952 cifs_zap_mapping(inode);
954 "Set no oplock for inode=%p after a write operation\n",
961 written = cifs_get_writer(cinode);
965 written = generic_file_write_iter(iocb, from);
967 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
970 rc = filemap_fdatawrite(inode->i_mapping);
972 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
976 cifs_put_writer(cinode);
980 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
982 struct cifsFileInfo *cfile = file->private_data;
983 struct cifs_tcon *tcon;
986 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
987 * the cached file length
989 if (whence != SEEK_SET && whence != SEEK_CUR) {
991 struct inode *inode = file_inode(file);
994 * We need to be sure that all dirty pages are written and the
995 * server has the newest file length.
997 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
998 inode->i_mapping->nrpages != 0) {
999 rc = filemap_fdatawait(inode->i_mapping);
1001 mapping_set_error(inode->i_mapping, rc);
1006 * Some applications poll for the file length in this strange
1007 * way so we must seek to end on non-oplocked files by
1008 * setting the revalidate time to zero.
1010 CIFS_I(inode)->time = 0;
1012 rc = cifs_revalidate_file_attr(file);
1016 if (cfile && cfile->tlink) {
1017 tcon = tlink_tcon(cfile->tlink);
1018 if (tcon->ses->server->ops->llseek)
1019 return tcon->ses->server->ops->llseek(file, tcon,
1022 return generic_file_llseek(file, offset, whence);
1026 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1029 * Note that this is called by vfs setlease with i_lock held to
1030 * protect *lease from going away.
1032 struct inode *inode = file_inode(file);
1033 struct cifsFileInfo *cfile = file->private_data;
1035 if (!(S_ISREG(inode->i_mode)))
1038 /* Check if file is oplocked if this is request for new lease */
1039 if (arg == F_UNLCK ||
1040 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1041 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1042 return generic_setlease(file, arg, lease, priv);
1043 else if (tlink_tcon(cfile->tlink)->local_lease &&
1044 !CIFS_CACHE_READ(CIFS_I(inode)))
1046 * If the server claims to support oplock on this file, then we
1047 * still need to check oplock even if the local_lease mount
1048 * option is set, but there are servers which do not support
1049 * oplock for which this mount option may be useful if the user
1050 * knows that the file won't be changed on the server by anyone
1053 return generic_setlease(file, arg, lease, priv);
1058 struct file_system_type cifs_fs_type = {
1059 .owner = THIS_MODULE,
1061 .init_fs_context = smb3_init_fs_context,
1062 .parameters = smb3_fs_parameters,
1063 .kill_sb = cifs_kill_sb,
1064 .fs_flags = FS_RENAME_DOES_D_MOVE,
1066 MODULE_ALIAS_FS("cifs");
1068 static struct file_system_type smb3_fs_type = {
1069 .owner = THIS_MODULE,
1071 .init_fs_context = smb3_init_fs_context,
1072 .parameters = smb3_fs_parameters,
1073 .kill_sb = cifs_kill_sb,
1074 .fs_flags = FS_RENAME_DOES_D_MOVE,
1076 MODULE_ALIAS_FS("smb3");
1077 MODULE_ALIAS("smb3");
1079 const struct inode_operations cifs_dir_inode_ops = {
1080 .create = cifs_create,
1081 .atomic_open = cifs_atomic_open,
1082 .lookup = cifs_lookup,
1083 .getattr = cifs_getattr,
1084 .unlink = cifs_unlink,
1085 .link = cifs_hardlink,
1086 .mkdir = cifs_mkdir,
1087 .rmdir = cifs_rmdir,
1088 .rename = cifs_rename2,
1089 .permission = cifs_permission,
1090 .setattr = cifs_setattr,
1091 .symlink = cifs_symlink,
1092 .mknod = cifs_mknod,
1093 .listxattr = cifs_listxattr,
1096 const struct inode_operations cifs_file_inode_ops = {
1097 .setattr = cifs_setattr,
1098 .getattr = cifs_getattr,
1099 .permission = cifs_permission,
1100 .listxattr = cifs_listxattr,
1101 .fiemap = cifs_fiemap,
1104 const struct inode_operations cifs_symlink_inode_ops = {
1105 .get_link = cifs_get_link,
1106 .permission = cifs_permission,
1107 .listxattr = cifs_listxattr,
1110 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1111 struct file *dst_file, loff_t destoff, loff_t len,
1112 unsigned int remap_flags)
1114 struct inode *src_inode = file_inode(src_file);
1115 struct inode *target_inode = file_inode(dst_file);
1116 struct cifsFileInfo *smb_file_src = src_file->private_data;
1117 struct cifsFileInfo *smb_file_target;
1118 struct cifs_tcon *target_tcon;
1122 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1125 cifs_dbg(FYI, "clone range\n");
1129 if (!src_file->private_data || !dst_file->private_data) {
1131 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1135 smb_file_target = dst_file->private_data;
1136 target_tcon = tlink_tcon(smb_file_target->tlink);
1139 * Note: cifs case is easier than btrfs since server responsible for
1140 * checks for proper open modes and file type and if it wants
1141 * server could even support copy of range where source = target
1143 lock_two_nondirectories(target_inode, src_inode);
1146 len = src_inode->i_size - off;
1148 cifs_dbg(FYI, "about to flush pages\n");
1149 /* should we flush first and last page first */
1150 truncate_inode_pages_range(&target_inode->i_data, destoff,
1151 PAGE_ALIGN(destoff + len)-1);
1153 if (target_tcon->ses->server->ops->duplicate_extents)
1154 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1155 smb_file_src, smb_file_target, off, len, destoff);
1159 /* force revalidate of size and timestamps of target file now
1160 that target is updated on the server */
1161 CIFS_I(target_inode)->time = 0;
1162 /* although unlocking in the reverse order from locking is not
1163 strictly necessary here it is a little cleaner to be consistent */
1164 unlock_two_nondirectories(src_inode, target_inode);
1167 return rc < 0 ? rc : len;
1170 ssize_t cifs_file_copychunk_range(unsigned int xid,
1171 struct file *src_file, loff_t off,
1172 struct file *dst_file, loff_t destoff,
1173 size_t len, unsigned int flags)
1175 struct inode *src_inode = file_inode(src_file);
1176 struct inode *target_inode = file_inode(dst_file);
1177 struct cifsFileInfo *smb_file_src;
1178 struct cifsFileInfo *smb_file_target;
1179 struct cifs_tcon *src_tcon;
1180 struct cifs_tcon *target_tcon;
1183 cifs_dbg(FYI, "copychunk range\n");
1185 if (!src_file->private_data || !dst_file->private_data) {
1187 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1192 smb_file_target = dst_file->private_data;
1193 smb_file_src = src_file->private_data;
1194 src_tcon = tlink_tcon(smb_file_src->tlink);
1195 target_tcon = tlink_tcon(smb_file_target->tlink);
1197 if (src_tcon->ses != target_tcon->ses) {
1198 cifs_dbg(VFS, "source and target of copy not on same server\n");
1203 if (!target_tcon->ses->server->ops->copychunk_range)
1207 * Note: cifs case is easier than btrfs since server responsible for
1208 * checks for proper open modes and file type and if it wants
1209 * server could even support copy of range where source = target
1211 lock_two_nondirectories(target_inode, src_inode);
1213 cifs_dbg(FYI, "about to flush pages\n");
1214 /* should we flush first and last page first */
1215 truncate_inode_pages(&target_inode->i_data, 0);
1217 rc = file_modified(dst_file);
1219 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1220 smb_file_src, smb_file_target, off, len, destoff);
1222 file_accessed(src_file);
1224 /* force revalidate of size and timestamps of target file now
1225 * that target is updated on the server
1227 CIFS_I(target_inode)->time = 0;
1228 /* although unlocking in the reverse order from locking is not
1229 * strictly necessary here it is a little cleaner to be consistent
1231 unlock_two_nondirectories(src_inode, target_inode);
1238 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1239 * is a dummy operation.
1241 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1243 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1249 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1250 struct file *dst_file, loff_t destoff,
1251 size_t len, unsigned int flags)
1253 unsigned int xid = get_xid();
1255 struct cifsFileInfo *cfile = dst_file->private_data;
1257 if (cfile->swapfile)
1260 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1264 if (rc == -EOPNOTSUPP || rc == -EXDEV)
1265 rc = generic_copy_file_range(src_file, off, dst_file,
1266 destoff, len, flags);
1270 const struct file_operations cifs_file_ops = {
1271 .read_iter = cifs_loose_read_iter,
1272 .write_iter = cifs_file_write_iter,
1274 .release = cifs_close,
1276 .flock = cifs_flock,
1277 .fsync = cifs_fsync,
1278 .flush = cifs_flush,
1279 .mmap = cifs_file_mmap,
1280 .splice_read = generic_file_splice_read,
1281 .splice_write = iter_file_splice_write,
1282 .llseek = cifs_llseek,
1283 .unlocked_ioctl = cifs_ioctl,
1284 .copy_file_range = cifs_copy_file_range,
1285 .remap_file_range = cifs_remap_file_range,
1286 .setlease = cifs_setlease,
1287 .fallocate = cifs_fallocate,
1290 const struct file_operations cifs_file_strict_ops = {
1291 .read_iter = cifs_strict_readv,
1292 .write_iter = cifs_strict_writev,
1294 .release = cifs_close,
1296 .flock = cifs_flock,
1297 .fsync = cifs_strict_fsync,
1298 .flush = cifs_flush,
1299 .mmap = cifs_file_strict_mmap,
1300 .splice_read = generic_file_splice_read,
1301 .splice_write = iter_file_splice_write,
1302 .llseek = cifs_llseek,
1303 .unlocked_ioctl = cifs_ioctl,
1304 .copy_file_range = cifs_copy_file_range,
1305 .remap_file_range = cifs_remap_file_range,
1306 .setlease = cifs_setlease,
1307 .fallocate = cifs_fallocate,
1310 const struct file_operations cifs_file_direct_ops = {
1311 .read_iter = cifs_direct_readv,
1312 .write_iter = cifs_direct_writev,
1314 .release = cifs_close,
1316 .flock = cifs_flock,
1317 .fsync = cifs_fsync,
1318 .flush = cifs_flush,
1319 .mmap = cifs_file_mmap,
1320 .splice_read = generic_file_splice_read,
1321 .splice_write = iter_file_splice_write,
1322 .unlocked_ioctl = cifs_ioctl,
1323 .copy_file_range = cifs_copy_file_range,
1324 .remap_file_range = cifs_remap_file_range,
1325 .llseek = cifs_llseek,
1326 .setlease = cifs_setlease,
1327 .fallocate = cifs_fallocate,
1330 const struct file_operations cifs_file_nobrl_ops = {
1331 .read_iter = cifs_loose_read_iter,
1332 .write_iter = cifs_file_write_iter,
1334 .release = cifs_close,
1335 .fsync = cifs_fsync,
1336 .flush = cifs_flush,
1337 .mmap = cifs_file_mmap,
1338 .splice_read = generic_file_splice_read,
1339 .splice_write = iter_file_splice_write,
1340 .llseek = cifs_llseek,
1341 .unlocked_ioctl = cifs_ioctl,
1342 .copy_file_range = cifs_copy_file_range,
1343 .remap_file_range = cifs_remap_file_range,
1344 .setlease = cifs_setlease,
1345 .fallocate = cifs_fallocate,
1348 const struct file_operations cifs_file_strict_nobrl_ops = {
1349 .read_iter = cifs_strict_readv,
1350 .write_iter = cifs_strict_writev,
1352 .release = cifs_close,
1353 .fsync = cifs_strict_fsync,
1354 .flush = cifs_flush,
1355 .mmap = cifs_file_strict_mmap,
1356 .splice_read = generic_file_splice_read,
1357 .splice_write = iter_file_splice_write,
1358 .llseek = cifs_llseek,
1359 .unlocked_ioctl = cifs_ioctl,
1360 .copy_file_range = cifs_copy_file_range,
1361 .remap_file_range = cifs_remap_file_range,
1362 .setlease = cifs_setlease,
1363 .fallocate = cifs_fallocate,
1366 const struct file_operations cifs_file_direct_nobrl_ops = {
1367 .read_iter = cifs_direct_readv,
1368 .write_iter = cifs_direct_writev,
1370 .release = cifs_close,
1371 .fsync = cifs_fsync,
1372 .flush = cifs_flush,
1373 .mmap = cifs_file_mmap,
1374 .splice_read = generic_file_splice_read,
1375 .splice_write = iter_file_splice_write,
1376 .unlocked_ioctl = cifs_ioctl,
1377 .copy_file_range = cifs_copy_file_range,
1378 .remap_file_range = cifs_remap_file_range,
1379 .llseek = cifs_llseek,
1380 .setlease = cifs_setlease,
1381 .fallocate = cifs_fallocate,
1384 const struct file_operations cifs_dir_ops = {
1385 .iterate_shared = cifs_readdir,
1386 .release = cifs_closedir,
1387 .read = generic_read_dir,
1388 .unlocked_ioctl = cifs_ioctl,
1389 .copy_file_range = cifs_copy_file_range,
1390 .remap_file_range = cifs_remap_file_range,
1391 .llseek = generic_file_llseek,
1392 .fsync = cifs_dir_fsync,
1396 cifs_init_once(void *inode)
1398 struct cifsInodeInfo *cifsi = inode;
1400 inode_init_once(&cifsi->vfs_inode);
1401 init_rwsem(&cifsi->lock_sem);
1405 cifs_init_inodecache(void)
1407 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1408 sizeof(struct cifsInodeInfo),
1409 0, (SLAB_RECLAIM_ACCOUNT|
1410 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1412 if (cifs_inode_cachep == NULL)
1419 cifs_destroy_inodecache(void)
1422 * Make sure all delayed rcu free inodes are flushed before we
1426 kmem_cache_destroy(cifs_inode_cachep);
1430 cifs_init_request_bufs(void)
1433 * SMB2 maximum header size is bigger than CIFS one - no problems to
1434 * allocate some more bytes for CIFS.
1436 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1438 if (CIFSMaxBufSize < 8192) {
1439 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1440 Unicode path name has to fit in any SMB/CIFS path based frames */
1441 CIFSMaxBufSize = 8192;
1442 } else if (CIFSMaxBufSize > 1024*127) {
1443 CIFSMaxBufSize = 1024 * 127;
1445 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1448 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1449 CIFSMaxBufSize, CIFSMaxBufSize);
1451 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1452 CIFSMaxBufSize + max_hdr_size, 0,
1453 SLAB_HWCACHE_ALIGN, 0,
1454 CIFSMaxBufSize + max_hdr_size,
1456 if (cifs_req_cachep == NULL)
1459 if (cifs_min_rcv < 1)
1461 else if (cifs_min_rcv > 64) {
1463 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1466 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1469 if (cifs_req_poolp == NULL) {
1470 kmem_cache_destroy(cifs_req_cachep);
1473 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1474 almost all handle based requests (but not write response, nor is it
1475 sufficient for path based requests). A smaller size would have
1476 been more efficient (compacting multiple slab items on one 4k page)
1477 for the case in which debug was on, but this larger size allows
1478 more SMBs to use small buffer alloc and is still much more
1479 efficient to alloc 1 per page off the slab compared to 17K (5page)
1480 alloc of large cifs buffers even when page debugging is on */
1481 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1482 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1483 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1484 if (cifs_sm_req_cachep == NULL) {
1485 mempool_destroy(cifs_req_poolp);
1486 kmem_cache_destroy(cifs_req_cachep);
1490 if (cifs_min_small < 2)
1492 else if (cifs_min_small > 256) {
1493 cifs_min_small = 256;
1494 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1497 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1498 cifs_sm_req_cachep);
1500 if (cifs_sm_req_poolp == NULL) {
1501 mempool_destroy(cifs_req_poolp);
1502 kmem_cache_destroy(cifs_req_cachep);
1503 kmem_cache_destroy(cifs_sm_req_cachep);
1511 cifs_destroy_request_bufs(void)
1513 mempool_destroy(cifs_req_poolp);
1514 kmem_cache_destroy(cifs_req_cachep);
1515 mempool_destroy(cifs_sm_req_poolp);
1516 kmem_cache_destroy(cifs_sm_req_cachep);
1520 cifs_init_mids(void)
1522 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1523 sizeof(struct mid_q_entry), 0,
1524 SLAB_HWCACHE_ALIGN, NULL);
1525 if (cifs_mid_cachep == NULL)
1528 /* 3 is a reasonable minimum number of simultaneous operations */
1529 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1530 if (cifs_mid_poolp == NULL) {
1531 kmem_cache_destroy(cifs_mid_cachep);
1539 cifs_destroy_mids(void)
1541 mempool_destroy(cifs_mid_poolp);
1542 kmem_cache_destroy(cifs_mid_cachep);
1550 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1552 * Initialize Global counters
1554 atomic_set(&sesInfoAllocCount, 0);
1555 atomic_set(&tconInfoAllocCount, 0);
1556 atomic_set(&tcpSesNextId, 0);
1557 atomic_set(&tcpSesAllocCount, 0);
1558 atomic_set(&tcpSesReconnectCount, 0);
1559 atomic_set(&tconInfoReconnectCount, 0);
1561 atomic_set(&bufAllocCount, 0);
1562 atomic_set(&smBufAllocCount, 0);
1563 #ifdef CONFIG_CIFS_STATS2
1564 atomic_set(&totBufAllocCount, 0);
1565 atomic_set(&totSmBufAllocCount, 0);
1566 if (slow_rsp_threshold < 1)
1567 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1568 else if (slow_rsp_threshold > 32767)
1570 "slow response threshold set higher than recommended (0 to 32767)\n");
1571 #endif /* CONFIG_CIFS_STATS2 */
1573 atomic_set(&midCount, 0);
1574 GlobalCurrentXid = 0;
1575 GlobalTotalActiveXid = 0;
1576 GlobalMaxActiveXid = 0;
1577 spin_lock_init(&cifs_tcp_ses_lock);
1578 spin_lock_init(&GlobalMid_Lock);
1580 cifs_lock_secret = get_random_u32();
1582 if (cifs_max_pending < 2) {
1583 cifs_max_pending = 2;
1584 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1585 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1586 cifs_max_pending = CIFS_MAX_REQ;
1587 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1591 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1594 goto out_clean_proc;
1598 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1599 * so that we don't launch too many worker threads but
1600 * Documentation/core-api/workqueue.rst recommends setting it to 0
1603 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1604 decrypt_wq = alloc_workqueue("smb3decryptd",
1605 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1608 goto out_destroy_cifsiod_wq;
1611 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1612 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1613 if (!fileinfo_put_wq) {
1615 goto out_destroy_decrypt_wq;
1618 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1619 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1620 if (!cifsoplockd_wq) {
1622 goto out_destroy_fileinfo_put_wq;
1625 deferredclose_wq = alloc_workqueue("deferredclose",
1626 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1627 if (!deferredclose_wq) {
1629 goto out_destroy_cifsoplockd_wq;
1632 rc = cifs_fscache_register();
1634 goto out_destroy_deferredclose_wq;
1636 rc = cifs_init_inodecache();
1638 goto out_unreg_fscache;
1640 rc = cifs_init_mids();
1642 goto out_destroy_inodecache;
1644 rc = cifs_init_request_bufs();
1646 goto out_destroy_mids;
1648 #ifdef CONFIG_CIFS_DFS_UPCALL
1649 rc = dfs_cache_init();
1651 goto out_destroy_request_bufs;
1652 #endif /* CONFIG_CIFS_DFS_UPCALL */
1653 #ifdef CONFIG_CIFS_UPCALL
1654 rc = init_cifs_spnego();
1656 goto out_destroy_dfs_cache;
1657 #endif /* CONFIG_CIFS_UPCALL */
1658 #ifdef CONFIG_CIFS_SWN_UPCALL
1659 rc = cifs_genl_init();
1661 goto out_register_key_type;
1662 #endif /* CONFIG_CIFS_SWN_UPCALL */
1664 rc = init_cifs_idmap();
1666 goto out_cifs_swn_init;
1668 rc = register_filesystem(&cifs_fs_type);
1670 goto out_init_cifs_idmap;
1672 rc = register_filesystem(&smb3_fs_type);
1674 unregister_filesystem(&cifs_fs_type);
1675 goto out_init_cifs_idmap;
1680 out_init_cifs_idmap:
1683 #ifdef CONFIG_CIFS_SWN_UPCALL
1685 out_register_key_type:
1687 #ifdef CONFIG_CIFS_UPCALL
1689 out_destroy_dfs_cache:
1691 #ifdef CONFIG_CIFS_DFS_UPCALL
1692 dfs_cache_destroy();
1693 out_destroy_request_bufs:
1695 cifs_destroy_request_bufs();
1697 cifs_destroy_mids();
1698 out_destroy_inodecache:
1699 cifs_destroy_inodecache();
1701 cifs_fscache_unregister();
1702 out_destroy_deferredclose_wq:
1703 destroy_workqueue(deferredclose_wq);
1704 out_destroy_cifsoplockd_wq:
1705 destroy_workqueue(cifsoplockd_wq);
1706 out_destroy_fileinfo_put_wq:
1707 destroy_workqueue(fileinfo_put_wq);
1708 out_destroy_decrypt_wq:
1709 destroy_workqueue(decrypt_wq);
1710 out_destroy_cifsiod_wq:
1711 destroy_workqueue(cifsiod_wq);
1720 cifs_dbg(NOISY, "exit_smb3\n");
1721 unregister_filesystem(&cifs_fs_type);
1722 unregister_filesystem(&smb3_fs_type);
1723 cifs_dfs_release_automount_timer();
1725 #ifdef CONFIG_CIFS_SWN_UPCALL
1728 #ifdef CONFIG_CIFS_UPCALL
1731 #ifdef CONFIG_CIFS_DFS_UPCALL
1732 dfs_cache_destroy();
1734 cifs_destroy_request_bufs();
1735 cifs_destroy_mids();
1736 cifs_destroy_inodecache();
1737 cifs_fscache_unregister();
1738 destroy_workqueue(deferredclose_wq);
1739 destroy_workqueue(cifsoplockd_wq);
1740 destroy_workqueue(decrypt_wq);
1741 destroy_workqueue(fileinfo_put_wq);
1742 destroy_workqueue(cifsiod_wq);
1746 MODULE_AUTHOR("Steve French");
1747 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1749 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1750 "also older servers complying with the SNIA CIFS Specification)");
1751 MODULE_VERSION(CIFS_VERSION);
1752 MODULE_SOFTDEP("ecb");
1753 MODULE_SOFTDEP("hmac");
1754 MODULE_SOFTDEP("md4");
1755 MODULE_SOFTDEP("md5");
1756 MODULE_SOFTDEP("nls");
1757 MODULE_SOFTDEP("aes");
1758 MODULE_SOFTDEP("cmac");
1759 MODULE_SOFTDEP("sha256");
1760 MODULE_SOFTDEP("sha512");
1761 MODULE_SOFTDEP("aead2");
1762 MODULE_SOFTDEP("ccm");
1763 MODULE_SOFTDEP("gcm");
1764 module_init(init_cifs)
1765 module_exit(exit_cifs)