4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Common Internet FileSystem (CIFS) client
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.
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.
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
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
26 #include <linux/module.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>
45 #define DECLARE_GLOBALS_HERE
47 #include "cifsproto.h"
48 #include "cifs_debug.h"
49 #include "cifs_fs_sb.h"
51 #include <linux/key-type.h>
52 #include "cifs_spnego.h"
55 #ifdef CONFIG_CIFS_DFS_UPCALL
56 #include "dfs_cache.h"
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.
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)
70 bool enable_oplocks = true;
71 bool linuxExtEnabled = true;
72 bool lookupCacheEnabled = true;
73 bool disable_legacy_dialects; /* false by default */
74 unsigned int global_secflags = CIFSSEC_DEF;
75 /* unsigned int ntlmv2_support = 0; */
76 unsigned int sign_CIFS_PDUs = 1;
77 static const struct super_operations cifs_super_ops;
78 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
79 module_param(CIFSMaxBufSize, uint, 0444);
80 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
82 "Default: 16384 Range: 8192 to 130048");
83 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
84 module_param(cifs_min_rcv, uint, 0444);
85 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
87 unsigned int cifs_min_small = 30;
88 module_param(cifs_min_small, uint, 0444);
89 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
91 unsigned int cifs_max_pending = CIFS_MAX_REQ;
92 module_param(cifs_max_pending, uint, 0444);
93 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
94 "CIFS/SMB1 dialect (N/A for SMB3) "
95 "Default: 32767 Range: 2 to 32767.");
96 #ifdef CONFIG_CIFS_STATS2
97 unsigned int slow_rsp_threshold = 1;
98 module_param(slow_rsp_threshold, uint, 0644);
99 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
100 "before logging that a response is delayed. "
101 "Default: 1 (if set to 0 disables msg).");
104 module_param(enable_oplocks, bool, 0644);
105 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
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 *cifsoplockd_wq;
123 __u32 cifs_lock_secret;
126 * Bumps refcount for cifs super block.
127 * Note that it should be only called if a referece to VFS super block is
128 * already held, e.g. in open-type syscalls context. Otherwise it can race with
129 * atomic_dec_and_test in deactivate_locked_super.
132 cifs_sb_active(struct super_block *sb)
134 struct cifs_sb_info *server = CIFS_SB(sb);
136 if (atomic_inc_return(&server->active) == 1)
137 atomic_inc(&sb->s_active);
141 cifs_sb_deactive(struct super_block *sb)
143 struct cifs_sb_info *server = CIFS_SB(sb);
145 if (atomic_dec_and_test(&server->active))
146 deactivate_super(sb);
150 cifs_read_super(struct super_block *sb)
153 struct cifs_sb_info *cifs_sb;
154 struct cifs_tcon *tcon;
155 struct timespec64 ts;
158 cifs_sb = CIFS_SB(sb);
159 tcon = cifs_sb_master_tcon(cifs_sb);
161 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
162 sb->s_flags |= SB_POSIXACL;
164 if (tcon->snapshot_time)
165 sb->s_flags |= SB_RDONLY;
167 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
168 sb->s_maxbytes = MAX_LFS_FILESIZE;
170 sb->s_maxbytes = MAX_NON_LFS;
172 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
173 sb->s_time_gran = 100;
175 if (tcon->unix_ext) {
176 ts = cifs_NTtimeToUnix(0);
177 sb->s_time_min = ts.tv_sec;
178 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
179 sb->s_time_max = ts.tv_sec;
181 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
182 sb->s_time_min = ts.tv_sec;
183 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX), cpu_to_le16(SMB_TIME_MAX), 0);
184 sb->s_time_max = ts.tv_sec;
187 sb->s_magic = CIFS_MAGIC_NUMBER;
188 sb->s_op = &cifs_super_ops;
189 sb->s_xattr = cifs_xattr_handlers;
190 rc = super_setup_bdi(sb);
193 /* tune readahead according to rsize */
194 sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
196 sb->s_blocksize = CIFS_MAX_MSGSIZE;
197 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
198 inode = cifs_root_iget(sb);
206 sb->s_d_op = &cifs_ci_dentry_ops;
208 sb->s_d_op = &cifs_dentry_ops;
210 sb->s_root = d_make_root(inode);
216 #ifdef CONFIG_CIFS_NFSD_EXPORT
217 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
218 cifs_dbg(FYI, "export ops supported\n");
219 sb->s_export_op = &cifs_export_ops;
221 #endif /* CONFIG_CIFS_NFSD_EXPORT */
226 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
230 static void cifs_kill_sb(struct super_block *sb)
232 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
234 cifs_umount(cifs_sb);
238 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
240 struct super_block *sb = dentry->d_sb;
241 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
242 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
243 struct TCP_Server_Info *server = tcon->ses->server;
249 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
251 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
253 buf->f_namelen = PATH_MAX;
255 buf->f_fsid.val[0] = tcon->vol_serial_number;
256 /* are using part of create time for more randomness, see man statfs */
257 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
259 buf->f_files = 0; /* undefined */
260 buf->f_ffree = 0; /* unlimited */
262 if (server->ops->queryfs)
263 rc = server->ops->queryfs(xid, tcon, buf);
269 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
271 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
272 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
273 struct TCP_Server_Info *server = tcon->ses->server;
275 if (server->ops->fallocate)
276 return server->ops->fallocate(file, tcon, mode, off, len);
281 static int cifs_permission(struct inode *inode, int mask)
283 struct cifs_sb_info *cifs_sb;
285 cifs_sb = CIFS_SB(inode->i_sb);
287 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
288 if ((mask & MAY_EXEC) && !execute_ok(inode))
292 } else /* file mode might have been restricted at mount time
293 on the client (above and beyond ACL on servers) for
294 servers which do not support setting and viewing mode bits,
295 so allowing client to check permissions is useful */
296 return generic_permission(inode, mask);
299 static struct kmem_cache *cifs_inode_cachep;
300 static struct kmem_cache *cifs_req_cachep;
301 static struct kmem_cache *cifs_mid_cachep;
302 static struct kmem_cache *cifs_sm_req_cachep;
303 mempool_t *cifs_sm_req_poolp;
304 mempool_t *cifs_req_poolp;
305 mempool_t *cifs_mid_poolp;
307 static struct inode *
308 cifs_alloc_inode(struct super_block *sb)
310 struct cifsInodeInfo *cifs_inode;
311 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
314 cifs_inode->cifsAttrs = 0x20; /* default */
315 cifs_inode->time = 0;
317 * Until the file is open and we have gotten oplock info back from the
318 * server, can not assume caching of file data or metadata.
320 cifs_set_oplock_level(cifs_inode, 0);
321 cifs_inode->flags = 0;
322 spin_lock_init(&cifs_inode->writers_lock);
323 cifs_inode->writers = 0;
324 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
325 cifs_inode->server_eof = 0;
326 cifs_inode->uniqueid = 0;
327 cifs_inode->createtime = 0;
328 cifs_inode->epoch = 0;
329 spin_lock_init(&cifs_inode->open_file_lock);
330 generate_random_uuid(cifs_inode->lease_key);
333 * Can not set i_flags here - they get immediately overwritten to zero
336 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
337 INIT_LIST_HEAD(&cifs_inode->openFileList);
338 INIT_LIST_HEAD(&cifs_inode->llist);
339 return &cifs_inode->vfs_inode;
343 cifs_free_inode(struct inode *inode)
345 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
349 cifs_evict_inode(struct inode *inode)
351 truncate_inode_pages_final(&inode->i_data);
353 cifs_fscache_release_inode_cookie(inode);
357 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
359 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
360 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
362 seq_puts(s, ",addr=");
364 switch (server->dstaddr.ss_family) {
366 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
369 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
370 if (sa6->sin6_scope_id)
371 seq_printf(s, "%%%u", sa6->sin6_scope_id);
374 seq_puts(s, "(unknown)");
377 seq_puts(s, ",rdma");
381 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
383 if (ses->sectype == Unspecified) {
384 if (ses->user_name == NULL)
385 seq_puts(s, ",sec=none");
389 seq_puts(s, ",sec=");
391 switch (ses->sectype) {
393 seq_puts(s, "lanman");
396 seq_puts(s, "ntlmv2");
402 seq_printf(s, "krb5,cruid=%u", from_kuid_munged(&init_user_ns,ses->cred_uid));
405 seq_puts(s, "ntlmssp");
408 /* shouldn't ever happen */
409 seq_puts(s, "unknown");
418 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
420 seq_puts(s, ",cache=");
422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
423 seq_puts(s, "strict");
424 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
426 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
427 seq_puts(s, "singleclient"); /* assume only one client access */
428 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
429 seq_puts(s, "ro"); /* read only caching assumed */
431 seq_puts(s, "loose");
435 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
437 struct nls_table *def;
439 /* Display iocharset= option if it's not default charset */
440 def = load_nls_default();
442 seq_printf(s, ",iocharset=%s", cur->charset);
447 * cifs_show_options() is for displaying mount options in /proc/mounts.
448 * Not all settable options are displayed but most of the important
452 cifs_show_options(struct seq_file *s, struct dentry *root)
454 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
455 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
456 struct sockaddr *srcaddr;
457 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
459 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
460 cifs_show_security(s, tcon->ses);
461 cifs_show_cache_flavor(s, cifs_sb);
464 seq_puts(s, ",nolease");
465 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
466 seq_puts(s, ",multiuser");
467 else if (tcon->ses->user_name)
468 seq_show_option(s, "username", tcon->ses->user_name);
470 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
471 seq_show_option(s, "domain", tcon->ses->domainName);
473 if (srcaddr->sa_family != AF_UNSPEC) {
474 struct sockaddr_in *saddr4;
475 struct sockaddr_in6 *saddr6;
476 saddr4 = (struct sockaddr_in *)srcaddr;
477 saddr6 = (struct sockaddr_in6 *)srcaddr;
478 if (srcaddr->sa_family == AF_INET6)
479 seq_printf(s, ",srcaddr=%pI6c",
481 else if (srcaddr->sa_family == AF_INET)
482 seq_printf(s, ",srcaddr=%pI4",
483 &saddr4->sin_addr.s_addr);
485 seq_printf(s, ",srcaddr=BAD-AF:%i",
486 (int)(srcaddr->sa_family));
489 seq_printf(s, ",uid=%u",
490 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
491 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
492 seq_puts(s, ",forceuid");
494 seq_puts(s, ",noforceuid");
496 seq_printf(s, ",gid=%u",
497 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
499 seq_puts(s, ",forcegid");
501 seq_puts(s, ",noforcegid");
503 cifs_show_address(s, tcon->ses->server);
506 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
507 cifs_sb->mnt_file_mode,
508 cifs_sb->mnt_dir_mode);
510 cifs_show_nls(s, cifs_sb->local_nls);
513 seq_puts(s, ",seal");
515 seq_puts(s, ",nocase");
516 if (tcon->local_lease)
517 seq_puts(s, ",locallease");
519 seq_puts(s, ",hard");
521 seq_puts(s, ",soft");
522 if (tcon->use_persistent)
523 seq_puts(s, ",persistenthandles");
524 else if (tcon->use_resilient)
525 seq_puts(s, ",resilienthandles");
526 if (tcon->posix_extensions)
527 seq_puts(s, ",posix");
528 else if (tcon->unix_ext)
529 seq_puts(s, ",unix");
531 seq_puts(s, ",nounix");
532 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
533 seq_puts(s, ",nodfs");
534 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
535 seq_puts(s, ",posixpaths");
536 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
537 seq_puts(s, ",setuids");
538 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
539 seq_puts(s, ",idsfromsid");
540 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
541 seq_puts(s, ",serverino");
542 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
543 seq_puts(s, ",rwpidforward");
544 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
545 seq_puts(s, ",forcemand");
546 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
547 seq_puts(s, ",nouser_xattr");
548 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
549 seq_puts(s, ",mapchars");
550 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
551 seq_puts(s, ",mapposix");
552 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
554 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
555 seq_puts(s, ",nobrl");
556 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
557 seq_puts(s, ",nohandlecache");
558 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
559 seq_puts(s, ",modefromsid");
560 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
561 seq_puts(s, ",cifsacl");
562 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
563 seq_puts(s, ",dynperm");
564 if (root->d_sb->s_flags & SB_POSIXACL)
566 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
567 seq_puts(s, ",mfsymlinks");
568 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
570 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
571 seq_puts(s, ",nostrictsync");
572 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
573 seq_puts(s, ",noperm");
574 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
575 seq_printf(s, ",backupuid=%u",
576 from_kuid_munged(&init_user_ns,
577 cifs_sb->mnt_backupuid));
578 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
579 seq_printf(s, ",backupgid=%u",
580 from_kgid_munged(&init_user_ns,
581 cifs_sb->mnt_backupgid));
583 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
584 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
585 seq_printf(s, ",bsize=%u", cifs_sb->bsize);
586 if (tcon->ses->server->min_offload)
587 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
588 seq_printf(s, ",echo_interval=%lu",
589 tcon->ses->server->echo_interval / HZ);
591 /* Only display max_credits if it was overridden on mount */
592 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
593 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
595 if (tcon->snapshot_time)
596 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
597 if (tcon->handle_timeout)
598 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
599 /* convert actimeo and display it in seconds */
600 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
605 static void cifs_umount_begin(struct super_block *sb)
607 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
608 struct cifs_tcon *tcon;
613 tcon = cifs_sb_master_tcon(cifs_sb);
615 spin_lock(&cifs_tcp_ses_lock);
616 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
617 /* we have other mounts to same share or we have
618 already tried to force umount this and woken up
619 all waiting network requests, nothing to do */
620 spin_unlock(&cifs_tcp_ses_lock);
622 } else if (tcon->tc_count == 1)
623 tcon->tidStatus = CifsExiting;
624 spin_unlock(&cifs_tcp_ses_lock);
626 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
627 /* cancel_notify_requests(tcon); */
628 if (tcon->ses && tcon->ses->server) {
629 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
630 wake_up_all(&tcon->ses->server->request_q);
631 wake_up_all(&tcon->ses->server->response_q);
632 msleep(1); /* yield */
633 /* we have to kick the requests once more */
634 wake_up_all(&tcon->ses->server->response_q);
641 #ifdef CONFIG_CIFS_STATS2
642 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
649 static int cifs_remount(struct super_block *sb, int *flags, char *data)
652 *flags |= SB_NODIRATIME;
656 static int cifs_drop_inode(struct inode *inode)
658 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
660 /* no serverino => unconditional eviction */
661 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
662 generic_drop_inode(inode);
665 static const struct super_operations cifs_super_ops = {
666 .statfs = cifs_statfs,
667 .alloc_inode = cifs_alloc_inode,
668 .free_inode = cifs_free_inode,
669 .drop_inode = cifs_drop_inode,
670 .evict_inode = cifs_evict_inode,
671 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
672 function unless later we add lazy close of inodes or unless the
673 kernel forgets to call us with the same number of releases (closes)
675 .show_options = cifs_show_options,
676 .umount_begin = cifs_umount_begin,
677 .remount_fs = cifs_remount,
678 #ifdef CONFIG_CIFS_STATS2
679 .show_stats = cifs_show_stats,
684 * Get root dentry from superblock according to prefix path mount option.
685 * Return dentry with refcount + 1 on success and NULL otherwise.
687 static struct dentry *
688 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
690 struct dentry *dentry;
691 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
692 char *full_path = NULL;
696 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
697 return dget(sb->s_root);
699 full_path = cifs_build_path_to_root(vol, cifs_sb,
700 cifs_sb_master_tcon(cifs_sb), 0);
701 if (full_path == NULL)
702 return ERR_PTR(-ENOMEM);
704 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
706 sep = CIFS_DIR_SEP(cifs_sb);
707 dentry = dget(sb->s_root);
711 struct inode *dir = d_inode(dentry);
712 struct dentry *child;
716 dentry = ERR_PTR(-ENOENT);
719 if (!S_ISDIR(dir->i_mode)) {
721 dentry = ERR_PTR(-ENOTDIR);
725 /* skip separators */
732 while (*s && *s != sep)
735 child = lookup_one_len_unlocked(p, dentry, s - p);
738 } while (!IS_ERR(dentry));
743 static int cifs_set_super(struct super_block *sb, void *data)
745 struct cifs_mnt_data *mnt_data = data;
746 sb->s_fs_info = mnt_data->cifs_sb;
747 return set_anon_super(sb, NULL);
750 static struct dentry *
751 cifs_smb3_do_mount(struct file_system_type *fs_type,
752 int flags, const char *dev_name, void *data, bool is_smb3)
755 struct super_block *sb;
756 struct cifs_sb_info *cifs_sb;
757 struct smb_vol *volume_info;
758 struct cifs_mnt_data mnt_data;
762 * Prints in Kernel / CIFS log the attempted mount operation
763 * If CIFS_DEBUG && cifs_FYI
766 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
768 cifs_info("Attempting to mount %s\n", dev_name);
770 volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
771 if (IS_ERR(volume_info))
772 return ERR_CAST(volume_info);
774 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
775 if (cifs_sb == NULL) {
776 root = ERR_PTR(-ENOMEM);
780 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
781 if (cifs_sb->mountdata == NULL) {
782 root = ERR_PTR(-ENOMEM);
786 rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
792 rc = cifs_mount(cifs_sb, volume_info);
794 if (!(flags & SB_SILENT))
795 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
801 mnt_data.vol = volume_info;
802 mnt_data.cifs_sb = cifs_sb;
803 mnt_data.flags = flags;
805 /* BB should we make this contingent on mount parm? */
806 flags |= SB_NODIRATIME | SB_NOATIME;
808 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
811 cifs_umount(cifs_sb);
816 cifs_dbg(FYI, "Use existing superblock\n");
817 cifs_umount(cifs_sb);
819 rc = cifs_read_super(sb);
825 sb->s_flags |= SB_ACTIVE;
828 root = cifs_get_root(volume_info, sb);
832 cifs_dbg(FYI, "dentry root is: %p\n", root);
836 deactivate_locked_super(sb);
838 cifs_cleanup_volume_info(volume_info);
842 kfree(cifs_sb->prepath);
843 kfree(cifs_sb->mountdata);
846 unload_nls(volume_info->local_nls);
850 static struct dentry *
851 smb3_do_mount(struct file_system_type *fs_type,
852 int flags, const char *dev_name, void *data)
854 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
857 static struct dentry *
858 cifs_do_mount(struct file_system_type *fs_type,
859 int flags, const char *dev_name, void *data)
861 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
865 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
868 struct inode *inode = file_inode(iocb->ki_filp);
870 if (iocb->ki_filp->f_flags & O_DIRECT)
871 return cifs_user_readv(iocb, iter);
873 rc = cifs_revalidate_mapping(inode);
877 return generic_file_read_iter(iocb, iter);
880 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
882 struct inode *inode = file_inode(iocb->ki_filp);
883 struct cifsInodeInfo *cinode = CIFS_I(inode);
887 if (iocb->ki_filp->f_flags & O_DIRECT) {
888 written = cifs_user_writev(iocb, from);
889 if (written > 0 && CIFS_CACHE_READ(cinode)) {
890 cifs_zap_mapping(inode);
892 "Set no oplock for inode=%p after a write operation\n",
899 written = cifs_get_writer(cinode);
903 written = generic_file_write_iter(iocb, from);
905 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
908 rc = filemap_fdatawrite(inode->i_mapping);
910 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
914 cifs_put_writer(cinode);
918 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
920 struct cifsFileInfo *cfile = file->private_data;
921 struct cifs_tcon *tcon;
924 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
925 * the cached file length
927 if (whence != SEEK_SET && whence != SEEK_CUR) {
929 struct inode *inode = file_inode(file);
932 * We need to be sure that all dirty pages are written and the
933 * server has the newest file length.
935 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
936 inode->i_mapping->nrpages != 0) {
937 rc = filemap_fdatawait(inode->i_mapping);
939 mapping_set_error(inode->i_mapping, rc);
944 * Some applications poll for the file length in this strange
945 * way so we must seek to end on non-oplocked files by
946 * setting the revalidate time to zero.
948 CIFS_I(inode)->time = 0;
950 rc = cifs_revalidate_file_attr(file);
954 if (cfile && cfile->tlink) {
955 tcon = tlink_tcon(cfile->tlink);
956 if (tcon->ses->server->ops->llseek)
957 return tcon->ses->server->ops->llseek(file, tcon,
960 return generic_file_llseek(file, offset, whence);
964 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
967 * Note that this is called by vfs setlease with i_lock held to
968 * protect *lease from going away.
970 struct inode *inode = file_inode(file);
971 struct cifsFileInfo *cfile = file->private_data;
973 if (!(S_ISREG(inode->i_mode)))
976 /* Check if file is oplocked if this is request for new lease */
977 if (arg == F_UNLCK ||
978 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
979 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
980 return generic_setlease(file, arg, lease, priv);
981 else if (tlink_tcon(cfile->tlink)->local_lease &&
982 !CIFS_CACHE_READ(CIFS_I(inode)))
984 * If the server claims to support oplock on this file, then we
985 * still need to check oplock even if the local_lease mount
986 * option is set, but there are servers which do not support
987 * oplock for which this mount option may be useful if the user
988 * knows that the file won't be changed on the server by anyone
991 return generic_setlease(file, arg, lease, priv);
996 struct file_system_type cifs_fs_type = {
997 .owner = THIS_MODULE,
999 .mount = cifs_do_mount,
1000 .kill_sb = cifs_kill_sb,
1003 MODULE_ALIAS_FS("cifs");
1005 static struct file_system_type smb3_fs_type = {
1006 .owner = THIS_MODULE,
1008 .mount = smb3_do_mount,
1009 .kill_sb = cifs_kill_sb,
1012 MODULE_ALIAS_FS("smb3");
1013 MODULE_ALIAS("smb3");
1015 const struct inode_operations cifs_dir_inode_ops = {
1016 .create = cifs_create,
1017 .atomic_open = cifs_atomic_open,
1018 .lookup = cifs_lookup,
1019 .getattr = cifs_getattr,
1020 .unlink = cifs_unlink,
1021 .link = cifs_hardlink,
1022 .mkdir = cifs_mkdir,
1023 .rmdir = cifs_rmdir,
1024 .rename = cifs_rename2,
1025 .permission = cifs_permission,
1026 .setattr = cifs_setattr,
1027 .symlink = cifs_symlink,
1028 .mknod = cifs_mknod,
1029 .listxattr = cifs_listxattr,
1032 const struct inode_operations cifs_file_inode_ops = {
1033 .setattr = cifs_setattr,
1034 .getattr = cifs_getattr,
1035 .permission = cifs_permission,
1036 .listxattr = cifs_listxattr,
1037 .fiemap = cifs_fiemap,
1040 const struct inode_operations cifs_symlink_inode_ops = {
1041 .get_link = cifs_get_link,
1042 .permission = cifs_permission,
1043 .listxattr = cifs_listxattr,
1046 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1047 struct file *dst_file, loff_t destoff, loff_t len,
1048 unsigned int remap_flags)
1050 struct inode *src_inode = file_inode(src_file);
1051 struct inode *target_inode = file_inode(dst_file);
1052 struct cifsFileInfo *smb_file_src = src_file->private_data;
1053 struct cifsFileInfo *smb_file_target;
1054 struct cifs_tcon *target_tcon;
1058 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1061 cifs_dbg(FYI, "clone range\n");
1065 if (!src_file->private_data || !dst_file->private_data) {
1067 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1071 smb_file_target = dst_file->private_data;
1072 target_tcon = tlink_tcon(smb_file_target->tlink);
1075 * Note: cifs case is easier than btrfs since server responsible for
1076 * checks for proper open modes and file type and if it wants
1077 * server could even support copy of range where source = target
1079 lock_two_nondirectories(target_inode, src_inode);
1082 len = src_inode->i_size - off;
1084 cifs_dbg(FYI, "about to flush pages\n");
1085 /* should we flush first and last page first */
1086 truncate_inode_pages_range(&target_inode->i_data, destoff,
1087 PAGE_ALIGN(destoff + len)-1);
1089 if (target_tcon->ses->server->ops->duplicate_extents)
1090 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1091 smb_file_src, smb_file_target, off, len, destoff);
1095 /* force revalidate of size and timestamps of target file now
1096 that target is updated on the server */
1097 CIFS_I(target_inode)->time = 0;
1098 /* although unlocking in the reverse order from locking is not
1099 strictly necessary here it is a little cleaner to be consistent */
1100 unlock_two_nondirectories(src_inode, target_inode);
1103 return rc < 0 ? rc : len;
1106 ssize_t cifs_file_copychunk_range(unsigned int xid,
1107 struct file *src_file, loff_t off,
1108 struct file *dst_file, loff_t destoff,
1109 size_t len, unsigned int flags)
1111 struct inode *src_inode = file_inode(src_file);
1112 struct inode *target_inode = file_inode(dst_file);
1113 struct cifsFileInfo *smb_file_src;
1114 struct cifsFileInfo *smb_file_target;
1115 struct cifs_tcon *src_tcon;
1116 struct cifs_tcon *target_tcon;
1119 cifs_dbg(FYI, "copychunk range\n");
1121 if (!src_file->private_data || !dst_file->private_data) {
1123 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1128 smb_file_target = dst_file->private_data;
1129 smb_file_src = src_file->private_data;
1130 src_tcon = tlink_tcon(smb_file_src->tlink);
1131 target_tcon = tlink_tcon(smb_file_target->tlink);
1133 if (src_tcon->ses != target_tcon->ses) {
1134 cifs_dbg(VFS, "source and target of copy not on same server\n");
1139 if (!target_tcon->ses->server->ops->copychunk_range)
1143 * Note: cifs case is easier than btrfs since server responsible for
1144 * checks for proper open modes and file type and if it wants
1145 * server could even support copy of range where source = target
1147 lock_two_nondirectories(target_inode, src_inode);
1149 cifs_dbg(FYI, "about to flush pages\n");
1150 /* should we flush first and last page first */
1151 truncate_inode_pages(&target_inode->i_data, 0);
1153 rc = file_modified(dst_file);
1155 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1156 smb_file_src, smb_file_target, off, len, destoff);
1158 file_accessed(src_file);
1160 /* force revalidate of size and timestamps of target file now
1161 * that target is updated on the server
1163 CIFS_I(target_inode)->time = 0;
1164 /* although unlocking in the reverse order from locking is not
1165 * strictly necessary here it is a little cleaner to be consistent
1167 unlock_two_nondirectories(src_inode, target_inode);
1174 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1175 * is a dummy operation.
1177 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1179 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1185 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1186 struct file *dst_file, loff_t destoff,
1187 size_t len, unsigned int flags)
1189 unsigned int xid = get_xid();
1192 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1196 if (rc == -EOPNOTSUPP || rc == -EXDEV)
1197 rc = generic_copy_file_range(src_file, off, dst_file,
1198 destoff, len, flags);
1202 const struct file_operations cifs_file_ops = {
1203 .read_iter = cifs_loose_read_iter,
1204 .write_iter = cifs_file_write_iter,
1206 .release = cifs_close,
1208 .fsync = cifs_fsync,
1209 .flush = cifs_flush,
1210 .mmap = cifs_file_mmap,
1211 .splice_read = generic_file_splice_read,
1212 .splice_write = iter_file_splice_write,
1213 .llseek = cifs_llseek,
1214 .unlocked_ioctl = cifs_ioctl,
1215 .copy_file_range = cifs_copy_file_range,
1216 .remap_file_range = cifs_remap_file_range,
1217 .setlease = cifs_setlease,
1218 .fallocate = cifs_fallocate,
1221 const struct file_operations cifs_file_strict_ops = {
1222 .read_iter = cifs_strict_readv,
1223 .write_iter = cifs_strict_writev,
1225 .release = cifs_close,
1227 .fsync = cifs_strict_fsync,
1228 .flush = cifs_flush,
1229 .mmap = cifs_file_strict_mmap,
1230 .splice_read = generic_file_splice_read,
1231 .splice_write = iter_file_splice_write,
1232 .llseek = cifs_llseek,
1233 .unlocked_ioctl = cifs_ioctl,
1234 .copy_file_range = cifs_copy_file_range,
1235 .remap_file_range = cifs_remap_file_range,
1236 .setlease = cifs_setlease,
1237 .fallocate = cifs_fallocate,
1240 const struct file_operations cifs_file_direct_ops = {
1241 .read_iter = cifs_direct_readv,
1242 .write_iter = cifs_direct_writev,
1244 .release = cifs_close,
1246 .fsync = cifs_fsync,
1247 .flush = cifs_flush,
1248 .mmap = cifs_file_mmap,
1249 .splice_read = generic_file_splice_read,
1250 .splice_write = iter_file_splice_write,
1251 .unlocked_ioctl = cifs_ioctl,
1252 .copy_file_range = cifs_copy_file_range,
1253 .remap_file_range = cifs_remap_file_range,
1254 .llseek = cifs_llseek,
1255 .setlease = cifs_setlease,
1256 .fallocate = cifs_fallocate,
1259 const struct file_operations cifs_file_nobrl_ops = {
1260 .read_iter = cifs_loose_read_iter,
1261 .write_iter = cifs_file_write_iter,
1263 .release = cifs_close,
1264 .fsync = cifs_fsync,
1265 .flush = cifs_flush,
1266 .mmap = cifs_file_mmap,
1267 .splice_read = generic_file_splice_read,
1268 .splice_write = iter_file_splice_write,
1269 .llseek = cifs_llseek,
1270 .unlocked_ioctl = cifs_ioctl,
1271 .copy_file_range = cifs_copy_file_range,
1272 .remap_file_range = cifs_remap_file_range,
1273 .setlease = cifs_setlease,
1274 .fallocate = cifs_fallocate,
1277 const struct file_operations cifs_file_strict_nobrl_ops = {
1278 .read_iter = cifs_strict_readv,
1279 .write_iter = cifs_strict_writev,
1281 .release = cifs_close,
1282 .fsync = cifs_strict_fsync,
1283 .flush = cifs_flush,
1284 .mmap = cifs_file_strict_mmap,
1285 .splice_read = generic_file_splice_read,
1286 .splice_write = iter_file_splice_write,
1287 .llseek = cifs_llseek,
1288 .unlocked_ioctl = cifs_ioctl,
1289 .copy_file_range = cifs_copy_file_range,
1290 .remap_file_range = cifs_remap_file_range,
1291 .setlease = cifs_setlease,
1292 .fallocate = cifs_fallocate,
1295 const struct file_operations cifs_file_direct_nobrl_ops = {
1296 .read_iter = cifs_direct_readv,
1297 .write_iter = cifs_direct_writev,
1299 .release = cifs_close,
1300 .fsync = cifs_fsync,
1301 .flush = cifs_flush,
1302 .mmap = cifs_file_mmap,
1303 .splice_read = generic_file_splice_read,
1304 .splice_write = iter_file_splice_write,
1305 .unlocked_ioctl = cifs_ioctl,
1306 .copy_file_range = cifs_copy_file_range,
1307 .remap_file_range = cifs_remap_file_range,
1308 .llseek = cifs_llseek,
1309 .setlease = cifs_setlease,
1310 .fallocate = cifs_fallocate,
1313 const struct file_operations cifs_dir_ops = {
1314 .iterate_shared = cifs_readdir,
1315 .release = cifs_closedir,
1316 .read = generic_read_dir,
1317 .unlocked_ioctl = cifs_ioctl,
1318 .copy_file_range = cifs_copy_file_range,
1319 .remap_file_range = cifs_remap_file_range,
1320 .llseek = generic_file_llseek,
1321 .fsync = cifs_dir_fsync,
1325 cifs_init_once(void *inode)
1327 struct cifsInodeInfo *cifsi = inode;
1329 inode_init_once(&cifsi->vfs_inode);
1330 init_rwsem(&cifsi->lock_sem);
1334 cifs_init_inodecache(void)
1336 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1337 sizeof(struct cifsInodeInfo),
1338 0, (SLAB_RECLAIM_ACCOUNT|
1339 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1341 if (cifs_inode_cachep == NULL)
1348 cifs_destroy_inodecache(void)
1351 * Make sure all delayed rcu free inodes are flushed before we
1355 kmem_cache_destroy(cifs_inode_cachep);
1359 cifs_init_request_bufs(void)
1362 * SMB2 maximum header size is bigger than CIFS one - no problems to
1363 * allocate some more bytes for CIFS.
1365 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1367 if (CIFSMaxBufSize < 8192) {
1368 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1369 Unicode path name has to fit in any SMB/CIFS path based frames */
1370 CIFSMaxBufSize = 8192;
1371 } else if (CIFSMaxBufSize > 1024*127) {
1372 CIFSMaxBufSize = 1024 * 127;
1374 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1377 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1378 CIFSMaxBufSize, CIFSMaxBufSize);
1380 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1381 CIFSMaxBufSize + max_hdr_size, 0,
1382 SLAB_HWCACHE_ALIGN, 0,
1383 CIFSMaxBufSize + max_hdr_size,
1385 if (cifs_req_cachep == NULL)
1388 if (cifs_min_rcv < 1)
1390 else if (cifs_min_rcv > 64) {
1392 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1395 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1398 if (cifs_req_poolp == NULL) {
1399 kmem_cache_destroy(cifs_req_cachep);
1402 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1403 almost all handle based requests (but not write response, nor is it
1404 sufficient for path based requests). A smaller size would have
1405 been more efficient (compacting multiple slab items on one 4k page)
1406 for the case in which debug was on, but this larger size allows
1407 more SMBs to use small buffer alloc and is still much more
1408 efficient to alloc 1 per page off the slab compared to 17K (5page)
1409 alloc of large cifs buffers even when page debugging is on */
1410 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1411 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1412 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1413 if (cifs_sm_req_cachep == NULL) {
1414 mempool_destroy(cifs_req_poolp);
1415 kmem_cache_destroy(cifs_req_cachep);
1419 if (cifs_min_small < 2)
1421 else if (cifs_min_small > 256) {
1422 cifs_min_small = 256;
1423 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1426 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1427 cifs_sm_req_cachep);
1429 if (cifs_sm_req_poolp == NULL) {
1430 mempool_destroy(cifs_req_poolp);
1431 kmem_cache_destroy(cifs_req_cachep);
1432 kmem_cache_destroy(cifs_sm_req_cachep);
1440 cifs_destroy_request_bufs(void)
1442 mempool_destroy(cifs_req_poolp);
1443 kmem_cache_destroy(cifs_req_cachep);
1444 mempool_destroy(cifs_sm_req_poolp);
1445 kmem_cache_destroy(cifs_sm_req_cachep);
1449 cifs_init_mids(void)
1451 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1452 sizeof(struct mid_q_entry), 0,
1453 SLAB_HWCACHE_ALIGN, NULL);
1454 if (cifs_mid_cachep == NULL)
1457 /* 3 is a reasonable minimum number of simultaneous operations */
1458 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1459 if (cifs_mid_poolp == NULL) {
1460 kmem_cache_destroy(cifs_mid_cachep);
1468 cifs_destroy_mids(void)
1470 mempool_destroy(cifs_mid_poolp);
1471 kmem_cache_destroy(cifs_mid_cachep);
1479 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1480 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1481 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1482 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1483 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1485 * Initialize Global counters
1487 atomic_set(&sesInfoAllocCount, 0);
1488 atomic_set(&tconInfoAllocCount, 0);
1489 atomic_set(&tcpSesAllocCount, 0);
1490 atomic_set(&tcpSesReconnectCount, 0);
1491 atomic_set(&tconInfoReconnectCount, 0);
1493 atomic_set(&bufAllocCount, 0);
1494 atomic_set(&smBufAllocCount, 0);
1495 #ifdef CONFIG_CIFS_STATS2
1496 atomic_set(&totBufAllocCount, 0);
1497 atomic_set(&totSmBufAllocCount, 0);
1498 if (slow_rsp_threshold < 1)
1499 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1500 else if (slow_rsp_threshold > 32767)
1502 "slow response threshold set higher than recommended (0 to 32767)\n");
1503 #endif /* CONFIG_CIFS_STATS2 */
1505 atomic_set(&midCount, 0);
1506 GlobalCurrentXid = 0;
1507 GlobalTotalActiveXid = 0;
1508 GlobalMaxActiveXid = 0;
1509 spin_lock_init(&cifs_tcp_ses_lock);
1510 spin_lock_init(&GlobalMid_Lock);
1512 cifs_lock_secret = get_random_u32();
1514 if (cifs_max_pending < 2) {
1515 cifs_max_pending = 2;
1516 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1517 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1518 cifs_max_pending = CIFS_MAX_REQ;
1519 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1523 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1526 goto out_clean_proc;
1530 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1531 * so that we don't launch too many worker threads but
1532 * Documentation/workqueue.txt recommends setting it to 0
1535 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1536 decrypt_wq = alloc_workqueue("smb3decryptd",
1537 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1540 goto out_destroy_cifsiod_wq;
1543 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1544 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1545 if (!cifsoplockd_wq) {
1547 goto out_destroy_decrypt_wq;
1550 rc = cifs_fscache_register();
1552 goto out_destroy_cifsoplockd_wq;
1554 rc = cifs_init_inodecache();
1556 goto out_unreg_fscache;
1558 rc = cifs_init_mids();
1560 goto out_destroy_inodecache;
1562 rc = cifs_init_request_bufs();
1564 goto out_destroy_mids;
1566 #ifdef CONFIG_CIFS_DFS_UPCALL
1567 rc = dfs_cache_init();
1569 goto out_destroy_request_bufs;
1570 #endif /* CONFIG_CIFS_DFS_UPCALL */
1571 #ifdef CONFIG_CIFS_UPCALL
1572 rc = init_cifs_spnego();
1574 goto out_destroy_dfs_cache;
1575 #endif /* CONFIG_CIFS_UPCALL */
1577 rc = init_cifs_idmap();
1579 goto out_register_key_type;
1581 rc = register_filesystem(&cifs_fs_type);
1583 goto out_init_cifs_idmap;
1585 rc = register_filesystem(&smb3_fs_type);
1587 unregister_filesystem(&cifs_fs_type);
1588 goto out_init_cifs_idmap;
1593 out_init_cifs_idmap:
1595 out_register_key_type:
1596 #ifdef CONFIG_CIFS_UPCALL
1598 out_destroy_dfs_cache:
1600 #ifdef CONFIG_CIFS_DFS_UPCALL
1601 dfs_cache_destroy();
1602 out_destroy_request_bufs:
1604 cifs_destroy_request_bufs();
1606 cifs_destroy_mids();
1607 out_destroy_inodecache:
1608 cifs_destroy_inodecache();
1610 cifs_fscache_unregister();
1611 out_destroy_cifsoplockd_wq:
1612 destroy_workqueue(cifsoplockd_wq);
1613 out_destroy_decrypt_wq:
1614 destroy_workqueue(decrypt_wq);
1615 out_destroy_cifsiod_wq:
1616 destroy_workqueue(cifsiod_wq);
1625 cifs_dbg(NOISY, "exit_smb3\n");
1626 unregister_filesystem(&cifs_fs_type);
1627 unregister_filesystem(&smb3_fs_type);
1628 cifs_dfs_release_automount_timer();
1630 #ifdef CONFIG_CIFS_UPCALL
1633 #ifdef CONFIG_CIFS_DFS_UPCALL
1634 dfs_cache_destroy();
1636 cifs_destroy_request_bufs();
1637 cifs_destroy_mids();
1638 cifs_destroy_inodecache();
1639 cifs_fscache_unregister();
1640 destroy_workqueue(cifsoplockd_wq);
1641 destroy_workqueue(decrypt_wq);
1642 destroy_workqueue(cifsiod_wq);
1646 MODULE_AUTHOR("Steve French");
1647 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1649 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1650 "also older servers complying with the SNIA CIFS Specification)");
1651 MODULE_VERSION(CIFS_VERSION);
1652 MODULE_SOFTDEP("pre: ecb");
1653 MODULE_SOFTDEP("pre: hmac");
1654 MODULE_SOFTDEP("pre: md4");
1655 MODULE_SOFTDEP("pre: md5");
1656 MODULE_SOFTDEP("pre: nls");
1657 MODULE_SOFTDEP("pre: aes");
1658 MODULE_SOFTDEP("pre: cmac");
1659 MODULE_SOFTDEP("pre: sha256");
1660 MODULE_SOFTDEP("pre: sha512");
1661 MODULE_SOFTDEP("pre: aead2");
1662 MODULE_SOFTDEP("pre: ccm");
1663 MODULE_SOFTDEP("pre: gcm");
1664 module_init(init_cifs)
1665 module_exit(exit_cifs)