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"
58 bool enable_oplocks = true;
59 bool linuxExtEnabled = true;
60 bool lookupCacheEnabled = true;
61 bool disable_legacy_dialects; /* false by default */
62 unsigned int global_secflags = CIFSSEC_DEF;
63 /* unsigned int ntlmv2_support = 0; */
64 unsigned int sign_CIFS_PDUs = 1;
65 static const struct super_operations cifs_super_ops;
66 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
67 module_param(CIFSMaxBufSize, uint, 0444);
68 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
70 "Default: 16384 Range: 8192 to 130048");
71 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
72 module_param(cifs_min_rcv, uint, 0444);
73 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
75 unsigned int cifs_min_small = 30;
76 module_param(cifs_min_small, uint, 0444);
77 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
79 unsigned int cifs_max_pending = CIFS_MAX_REQ;
80 module_param(cifs_max_pending, uint, 0444);
81 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
82 "CIFS/SMB1 dialect (N/A for SMB3) "
83 "Default: 32767 Range: 2 to 32767.");
84 module_param(enable_oplocks, bool, 0644);
85 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
87 module_param(disable_legacy_dialects, bool, 0644);
88 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
89 "helpful to restrict the ability to "
90 "override the default dialects (SMB2.1, "
91 "SMB3 and SMB3.02) on mount with old "
92 "dialects (CIFS/SMB1 and SMB2) since "
93 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
94 " and less secure. Default: n/N/0");
96 extern mempool_t *cifs_sm_req_poolp;
97 extern mempool_t *cifs_req_poolp;
98 extern mempool_t *cifs_mid_poolp;
100 struct workqueue_struct *cifsiod_wq;
101 struct workqueue_struct *cifsoplockd_wq;
102 __u32 cifs_lock_secret;
105 * Bumps refcount for cifs super block.
106 * Note that it should be only called if a referece to VFS super block is
107 * already held, e.g. in open-type syscalls context. Otherwise it can race with
108 * atomic_dec_and_test in deactivate_locked_super.
111 cifs_sb_active(struct super_block *sb)
113 struct cifs_sb_info *server = CIFS_SB(sb);
115 if (atomic_inc_return(&server->active) == 1)
116 atomic_inc(&sb->s_active);
120 cifs_sb_deactive(struct super_block *sb)
122 struct cifs_sb_info *server = CIFS_SB(sb);
124 if (atomic_dec_and_test(&server->active))
125 deactivate_super(sb);
129 cifs_read_super(struct super_block *sb)
132 struct cifs_sb_info *cifs_sb;
133 struct cifs_tcon *tcon;
136 cifs_sb = CIFS_SB(sb);
137 tcon = cifs_sb_master_tcon(cifs_sb);
139 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
140 sb->s_flags |= SB_POSIXACL;
142 if (tcon->snapshot_time)
143 sb->s_flags |= SB_RDONLY;
145 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
146 sb->s_maxbytes = MAX_LFS_FILESIZE;
148 sb->s_maxbytes = MAX_NON_LFS;
150 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
151 sb->s_time_gran = 100;
153 sb->s_magic = CIFS_MAGIC_NUMBER;
154 sb->s_op = &cifs_super_ops;
155 sb->s_xattr = cifs_xattr_handlers;
156 rc = super_setup_bdi(sb);
159 /* tune readahead according to rsize */
160 sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
162 sb->s_blocksize = CIFS_MAX_MSGSIZE;
163 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
164 inode = cifs_root_iget(sb);
172 sb->s_d_op = &cifs_ci_dentry_ops;
174 sb->s_d_op = &cifs_dentry_ops;
176 sb->s_root = d_make_root(inode);
182 #ifdef CONFIG_CIFS_NFSD_EXPORT
183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
184 cifs_dbg(FYI, "export ops supported\n");
185 sb->s_export_op = &cifs_export_ops;
187 #endif /* CONFIG_CIFS_NFSD_EXPORT */
192 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
196 static void cifs_kill_sb(struct super_block *sb)
198 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
200 cifs_umount(cifs_sb);
204 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
206 struct super_block *sb = dentry->d_sb;
207 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
208 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
209 struct TCP_Server_Info *server = tcon->ses->server;
215 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
217 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
219 buf->f_namelen = PATH_MAX;
221 buf->f_fsid.val[0] = tcon->vol_serial_number;
222 /* are using part of create time for more randomness, see man statfs */
223 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
225 buf->f_files = 0; /* undefined */
226 buf->f_ffree = 0; /* unlimited */
228 if (server->ops->queryfs)
229 rc = server->ops->queryfs(xid, tcon, buf);
235 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
237 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
238 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
239 struct TCP_Server_Info *server = tcon->ses->server;
241 if (server->ops->fallocate)
242 return server->ops->fallocate(file, tcon, mode, off, len);
247 static int cifs_permission(struct inode *inode, int mask)
249 struct cifs_sb_info *cifs_sb;
251 cifs_sb = CIFS_SB(inode->i_sb);
253 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
254 if ((mask & MAY_EXEC) && !execute_ok(inode))
258 } else /* file mode might have been restricted at mount time
259 on the client (above and beyond ACL on servers) for
260 servers which do not support setting and viewing mode bits,
261 so allowing client to check permissions is useful */
262 return generic_permission(inode, mask);
265 static struct kmem_cache *cifs_inode_cachep;
266 static struct kmem_cache *cifs_req_cachep;
267 static struct kmem_cache *cifs_mid_cachep;
268 static struct kmem_cache *cifs_sm_req_cachep;
269 mempool_t *cifs_sm_req_poolp;
270 mempool_t *cifs_req_poolp;
271 mempool_t *cifs_mid_poolp;
273 static struct inode *
274 cifs_alloc_inode(struct super_block *sb)
276 struct cifsInodeInfo *cifs_inode;
277 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
280 cifs_inode->cifsAttrs = 0x20; /* default */
281 cifs_inode->time = 0;
283 * Until the file is open and we have gotten oplock info back from the
284 * server, can not assume caching of file data or metadata.
286 cifs_set_oplock_level(cifs_inode, 0);
287 cifs_inode->flags = 0;
288 spin_lock_init(&cifs_inode->writers_lock);
289 cifs_inode->writers = 0;
290 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
291 cifs_inode->server_eof = 0;
292 cifs_inode->uniqueid = 0;
293 cifs_inode->createtime = 0;
294 cifs_inode->epoch = 0;
295 spin_lock_init(&cifs_inode->open_file_lock);
296 generate_random_uuid(cifs_inode->lease_key);
299 * Can not set i_flags here - they get immediately overwritten to zero
302 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
303 INIT_LIST_HEAD(&cifs_inode->openFileList);
304 INIT_LIST_HEAD(&cifs_inode->llist);
305 return &cifs_inode->vfs_inode;
308 static void cifs_i_callback(struct rcu_head *head)
310 struct inode *inode = container_of(head, struct inode, i_rcu);
311 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
315 cifs_destroy_inode(struct inode *inode)
317 call_rcu(&inode->i_rcu, cifs_i_callback);
321 cifs_evict_inode(struct inode *inode)
323 truncate_inode_pages_final(&inode->i_data);
325 cifs_fscache_release_inode_cookie(inode);
329 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
331 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
332 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
334 seq_puts(s, ",addr=");
336 switch (server->dstaddr.ss_family) {
338 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
341 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
342 if (sa6->sin6_scope_id)
343 seq_printf(s, "%%%u", sa6->sin6_scope_id);
346 seq_puts(s, "(unknown)");
349 seq_puts(s, ",rdma");
353 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
355 if (ses->sectype == Unspecified) {
356 if (ses->user_name == NULL)
357 seq_puts(s, ",sec=none");
361 seq_puts(s, ",sec=");
363 switch (ses->sectype) {
365 seq_puts(s, "lanman");
368 seq_puts(s, "ntlmv2");
377 seq_puts(s, "ntlmssp");
380 /* shouldn't ever happen */
381 seq_puts(s, "unknown");
390 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
392 seq_puts(s, ",cache=");
394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
395 seq_puts(s, "strict");
396 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
399 seq_puts(s, "loose");
403 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
405 struct nls_table *def;
407 /* Display iocharset= option if it's not default charset */
408 def = load_nls_default();
410 seq_printf(s, ",iocharset=%s", cur->charset);
415 * cifs_show_options() is for displaying mount options in /proc/mounts.
416 * Not all settable options are displayed but most of the important
420 cifs_show_options(struct seq_file *s, struct dentry *root)
422 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
423 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
424 struct sockaddr *srcaddr;
425 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
427 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
428 cifs_show_security(s, tcon->ses);
429 cifs_show_cache_flavor(s, cifs_sb);
432 seq_puts(s, ",nolease");
433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
434 seq_puts(s, ",multiuser");
435 else if (tcon->ses->user_name)
436 seq_show_option(s, "username", tcon->ses->user_name);
438 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
439 seq_show_option(s, "domain", tcon->ses->domainName);
441 if (srcaddr->sa_family != AF_UNSPEC) {
442 struct sockaddr_in *saddr4;
443 struct sockaddr_in6 *saddr6;
444 saddr4 = (struct sockaddr_in *)srcaddr;
445 saddr6 = (struct sockaddr_in6 *)srcaddr;
446 if (srcaddr->sa_family == AF_INET6)
447 seq_printf(s, ",srcaddr=%pI6c",
449 else if (srcaddr->sa_family == AF_INET)
450 seq_printf(s, ",srcaddr=%pI4",
451 &saddr4->sin_addr.s_addr);
453 seq_printf(s, ",srcaddr=BAD-AF:%i",
454 (int)(srcaddr->sa_family));
457 seq_printf(s, ",uid=%u",
458 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
459 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
460 seq_puts(s, ",forceuid");
462 seq_puts(s, ",noforceuid");
464 seq_printf(s, ",gid=%u",
465 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
466 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
467 seq_puts(s, ",forcegid");
469 seq_puts(s, ",noforcegid");
471 cifs_show_address(s, tcon->ses->server);
474 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
475 cifs_sb->mnt_file_mode,
476 cifs_sb->mnt_dir_mode);
478 cifs_show_nls(s, cifs_sb->local_nls);
481 seq_puts(s, ",seal");
483 seq_puts(s, ",nocase");
485 seq_puts(s, ",hard");
487 seq_puts(s, ",soft");
488 if (tcon->use_persistent)
489 seq_puts(s, ",persistenthandles");
490 else if (tcon->use_resilient)
491 seq_puts(s, ",resilienthandles");
492 if (tcon->posix_extensions)
493 seq_puts(s, ",posix");
494 else if (tcon->unix_ext)
495 seq_puts(s, ",unix");
497 seq_puts(s, ",nounix");
498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
499 seq_puts(s, ",posixpaths");
500 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
501 seq_puts(s, ",setuids");
502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
503 seq_puts(s, ",idsfromsid");
504 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
505 seq_puts(s, ",serverino");
506 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
507 seq_puts(s, ",rwpidforward");
508 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
509 seq_puts(s, ",forcemand");
510 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
511 seq_puts(s, ",nouser_xattr");
512 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
513 seq_puts(s, ",mapchars");
514 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
515 seq_puts(s, ",mapposix");
516 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
518 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
519 seq_puts(s, ",nobrl");
520 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
521 seq_puts(s, ",nohandlecache");
522 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
523 seq_puts(s, ",cifsacl");
524 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
525 seq_puts(s, ",dynperm");
526 if (root->d_sb->s_flags & SB_POSIXACL)
528 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
529 seq_puts(s, ",mfsymlinks");
530 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
532 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
533 seq_puts(s, ",nostrictsync");
534 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
535 seq_puts(s, ",noperm");
536 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
537 seq_printf(s, ",backupuid=%u",
538 from_kuid_munged(&init_user_ns,
539 cifs_sb->mnt_backupuid));
540 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
541 seq_printf(s, ",backupgid=%u",
542 from_kgid_munged(&init_user_ns,
543 cifs_sb->mnt_backupgid));
545 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
546 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
547 seq_printf(s, ",echo_interval=%lu",
548 tcon->ses->server->echo_interval / HZ);
549 if (tcon->snapshot_time)
550 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
551 /* convert actimeo and display it in seconds */
552 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
557 static void cifs_umount_begin(struct super_block *sb)
559 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
560 struct cifs_tcon *tcon;
565 tcon = cifs_sb_master_tcon(cifs_sb);
567 spin_lock(&cifs_tcp_ses_lock);
568 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
569 /* we have other mounts to same share or we have
570 already tried to force umount this and woken up
571 all waiting network requests, nothing to do */
572 spin_unlock(&cifs_tcp_ses_lock);
574 } else if (tcon->tc_count == 1)
575 tcon->tidStatus = CifsExiting;
576 spin_unlock(&cifs_tcp_ses_lock);
578 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
579 /* cancel_notify_requests(tcon); */
580 if (tcon->ses && tcon->ses->server) {
581 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
582 wake_up_all(&tcon->ses->server->request_q);
583 wake_up_all(&tcon->ses->server->response_q);
584 msleep(1); /* yield */
585 /* we have to kick the requests once more */
586 wake_up_all(&tcon->ses->server->response_q);
593 #ifdef CONFIG_CIFS_STATS2
594 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
601 static int cifs_remount(struct super_block *sb, int *flags, char *data)
604 *flags |= SB_NODIRATIME;
608 static int cifs_drop_inode(struct inode *inode)
610 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
612 /* no serverino => unconditional eviction */
613 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
614 generic_drop_inode(inode);
617 static const struct super_operations cifs_super_ops = {
618 .statfs = cifs_statfs,
619 .alloc_inode = cifs_alloc_inode,
620 .destroy_inode = cifs_destroy_inode,
621 .drop_inode = cifs_drop_inode,
622 .evict_inode = cifs_evict_inode,
623 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
624 function unless later we add lazy close of inodes or unless the
625 kernel forgets to call us with the same number of releases (closes)
627 .show_options = cifs_show_options,
628 .umount_begin = cifs_umount_begin,
629 .remount_fs = cifs_remount,
630 #ifdef CONFIG_CIFS_STATS2
631 .show_stats = cifs_show_stats,
636 * Get root dentry from superblock according to prefix path mount option.
637 * Return dentry with refcount + 1 on success and NULL otherwise.
639 static struct dentry *
640 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
642 struct dentry *dentry;
643 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
644 char *full_path = NULL;
648 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
649 return dget(sb->s_root);
651 full_path = cifs_build_path_to_root(vol, cifs_sb,
652 cifs_sb_master_tcon(cifs_sb), 0);
653 if (full_path == NULL)
654 return ERR_PTR(-ENOMEM);
656 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
658 sep = CIFS_DIR_SEP(cifs_sb);
659 dentry = dget(sb->s_root);
663 struct inode *dir = d_inode(dentry);
664 struct dentry *child;
668 dentry = ERR_PTR(-ENOENT);
671 if (!S_ISDIR(dir->i_mode)) {
673 dentry = ERR_PTR(-ENOTDIR);
677 /* skip separators */
684 while (*s && *s != sep)
687 child = lookup_one_len_unlocked(p, dentry, s - p);
690 } while (!IS_ERR(dentry));
695 static int cifs_set_super(struct super_block *sb, void *data)
697 struct cifs_mnt_data *mnt_data = data;
698 sb->s_fs_info = mnt_data->cifs_sb;
699 return set_anon_super(sb, NULL);
702 static struct dentry *
703 cifs_smb3_do_mount(struct file_system_type *fs_type,
704 int flags, const char *dev_name, void *data, bool is_smb3)
707 struct super_block *sb;
708 struct cifs_sb_info *cifs_sb;
709 struct smb_vol *volume_info;
710 struct cifs_mnt_data mnt_data;
713 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
715 volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
716 if (IS_ERR(volume_info))
717 return ERR_CAST(volume_info);
719 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
720 if (cifs_sb == NULL) {
721 root = ERR_PTR(-ENOMEM);
725 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
726 if (cifs_sb->mountdata == NULL) {
727 root = ERR_PTR(-ENOMEM);
731 rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
737 rc = cifs_mount(cifs_sb, volume_info);
739 if (!(flags & SB_SILENT))
740 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
746 mnt_data.vol = volume_info;
747 mnt_data.cifs_sb = cifs_sb;
748 mnt_data.flags = flags;
750 /* BB should we make this contingent on mount parm? */
751 flags |= SB_NODIRATIME | SB_NOATIME;
753 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
756 cifs_umount(cifs_sb);
761 cifs_dbg(FYI, "Use existing superblock\n");
762 cifs_umount(cifs_sb);
764 rc = cifs_read_super(sb);
770 sb->s_flags |= SB_ACTIVE;
773 root = cifs_get_root(volume_info, sb);
777 cifs_dbg(FYI, "dentry root is: %p\n", root);
781 deactivate_locked_super(sb);
784 cifs_cleanup_volume_info(volume_info);
788 kfree(cifs_sb->prepath);
789 kfree(cifs_sb->mountdata);
792 unload_nls(volume_info->local_nls);
796 static struct dentry *
797 smb3_do_mount(struct file_system_type *fs_type,
798 int flags, const char *dev_name, void *data)
800 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
803 static struct dentry *
804 cifs_do_mount(struct file_system_type *fs_type,
805 int flags, const char *dev_name, void *data)
807 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
811 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
814 struct inode *inode = file_inode(iocb->ki_filp);
816 if (iocb->ki_flags & IOCB_DIRECT)
817 return cifs_user_readv(iocb, iter);
819 rc = cifs_revalidate_mapping(inode);
823 return generic_file_read_iter(iocb, iter);
826 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
828 struct inode *inode = file_inode(iocb->ki_filp);
829 struct cifsInodeInfo *cinode = CIFS_I(inode);
833 if (iocb->ki_filp->f_flags & O_DIRECT) {
834 written = cifs_user_writev(iocb, from);
835 if (written > 0 && CIFS_CACHE_READ(cinode)) {
836 cifs_zap_mapping(inode);
838 "Set no oplock for inode=%p after a write operation\n",
845 written = cifs_get_writer(cinode);
849 written = generic_file_write_iter(iocb, from);
851 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
854 rc = filemap_fdatawrite(inode->i_mapping);
856 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
860 cifs_put_writer(cinode);
864 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
867 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
868 * the cached file length
870 if (whence != SEEK_SET && whence != SEEK_CUR) {
872 struct inode *inode = file_inode(file);
875 * We need to be sure that all dirty pages are written and the
876 * server has the newest file length.
878 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
879 inode->i_mapping->nrpages != 0) {
880 rc = filemap_fdatawait(inode->i_mapping);
882 mapping_set_error(inode->i_mapping, rc);
887 * Some applications poll for the file length in this strange
888 * way so we must seek to end on non-oplocked files by
889 * setting the revalidate time to zero.
891 CIFS_I(inode)->time = 0;
893 rc = cifs_revalidate_file_attr(file);
897 return generic_file_llseek(file, offset, whence);
901 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
904 * Note that this is called by vfs setlease with i_lock held to
905 * protect *lease from going away.
907 struct inode *inode = file_inode(file);
908 struct cifsFileInfo *cfile = file->private_data;
910 if (!(S_ISREG(inode->i_mode)))
913 /* Check if file is oplocked if this is request for new lease */
914 if (arg == F_UNLCK ||
915 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
916 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
917 return generic_setlease(file, arg, lease, priv);
918 else if (tlink_tcon(cfile->tlink)->local_lease &&
919 !CIFS_CACHE_READ(CIFS_I(inode)))
921 * If the server claims to support oplock on this file, then we
922 * still need to check oplock even if the local_lease mount
923 * option is set, but there are servers which do not support
924 * oplock for which this mount option may be useful if the user
925 * knows that the file won't be changed on the server by anyone
928 return generic_setlease(file, arg, lease, priv);
933 struct file_system_type cifs_fs_type = {
934 .owner = THIS_MODULE,
936 .mount = cifs_do_mount,
937 .kill_sb = cifs_kill_sb,
940 MODULE_ALIAS_FS("cifs");
942 static struct file_system_type smb3_fs_type = {
943 .owner = THIS_MODULE,
945 .mount = smb3_do_mount,
946 .kill_sb = cifs_kill_sb,
949 MODULE_ALIAS_FS("smb3");
950 MODULE_ALIAS("smb3");
952 const struct inode_operations cifs_dir_inode_ops = {
953 .create = cifs_create,
954 .atomic_open = cifs_atomic_open,
955 .lookup = cifs_lookup,
956 .getattr = cifs_getattr,
957 .unlink = cifs_unlink,
958 .link = cifs_hardlink,
961 .rename = cifs_rename2,
962 .permission = cifs_permission,
963 .setattr = cifs_setattr,
964 .symlink = cifs_symlink,
966 .listxattr = cifs_listxattr,
969 const struct inode_operations cifs_file_inode_ops = {
970 .setattr = cifs_setattr,
971 .getattr = cifs_getattr,
972 .permission = cifs_permission,
973 .listxattr = cifs_listxattr,
976 const struct inode_operations cifs_symlink_inode_ops = {
977 .get_link = cifs_get_link,
978 .permission = cifs_permission,
979 .listxattr = cifs_listxattr,
982 static int cifs_clone_file_range(struct file *src_file, loff_t off,
983 struct file *dst_file, loff_t destoff, u64 len)
985 struct inode *src_inode = file_inode(src_file);
986 struct inode *target_inode = file_inode(dst_file);
987 struct cifsFileInfo *smb_file_src = src_file->private_data;
988 struct cifsFileInfo *smb_file_target;
989 struct cifs_tcon *target_tcon;
993 cifs_dbg(FYI, "clone range\n");
997 if (!src_file->private_data || !dst_file->private_data) {
999 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1003 smb_file_target = dst_file->private_data;
1004 target_tcon = tlink_tcon(smb_file_target->tlink);
1007 * Note: cifs case is easier than btrfs since server responsible for
1008 * checks for proper open modes and file type and if it wants
1009 * server could even support copy of range where source = target
1011 lock_two_nondirectories(target_inode, src_inode);
1014 len = src_inode->i_size - off;
1016 cifs_dbg(FYI, "about to flush pages\n");
1017 /* should we flush first and last page first */
1018 truncate_inode_pages_range(&target_inode->i_data, destoff,
1019 PAGE_ALIGN(destoff + len)-1);
1021 if (target_tcon->ses->server->ops->duplicate_extents)
1022 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1023 smb_file_src, smb_file_target, off, len, destoff);
1027 /* force revalidate of size and timestamps of target file now
1028 that target is updated on the server */
1029 CIFS_I(target_inode)->time = 0;
1030 /* although unlocking in the reverse order from locking is not
1031 strictly necessary here it is a little cleaner to be consistent */
1032 unlock_two_nondirectories(src_inode, target_inode);
1038 ssize_t cifs_file_copychunk_range(unsigned int xid,
1039 struct file *src_file, loff_t off,
1040 struct file *dst_file, loff_t destoff,
1041 size_t len, unsigned int flags)
1043 struct inode *src_inode = file_inode(src_file);
1044 struct inode *target_inode = file_inode(dst_file);
1045 struct cifsFileInfo *smb_file_src;
1046 struct cifsFileInfo *smb_file_target;
1047 struct cifs_tcon *src_tcon;
1048 struct cifs_tcon *target_tcon;
1051 cifs_dbg(FYI, "copychunk range\n");
1053 if (src_inode == target_inode) {
1058 if (!src_file->private_data || !dst_file->private_data) {
1060 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1065 smb_file_target = dst_file->private_data;
1066 smb_file_src = src_file->private_data;
1067 src_tcon = tlink_tcon(smb_file_src->tlink);
1068 target_tcon = tlink_tcon(smb_file_target->tlink);
1070 if (src_tcon->ses != target_tcon->ses) {
1071 cifs_dbg(VFS, "source and target of copy not on same server\n");
1076 * Note: cifs case is easier than btrfs since server responsible for
1077 * checks for proper open modes and file type and if it wants
1078 * server could even support copy of range where source = target
1080 lock_two_nondirectories(target_inode, src_inode);
1082 cifs_dbg(FYI, "about to flush pages\n");
1083 /* should we flush first and last page first */
1084 truncate_inode_pages(&target_inode->i_data, 0);
1086 if (target_tcon->ses->server->ops->copychunk_range)
1087 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1088 smb_file_src, smb_file_target, off, len, destoff);
1092 /* force revalidate of size and timestamps of target file now
1093 * that target is updated on the server
1095 CIFS_I(target_inode)->time = 0;
1096 /* although unlocking in the reverse order from locking is not
1097 * strictly necessary here it is a little cleaner to be consistent
1099 unlock_two_nondirectories(src_inode, target_inode);
1106 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1107 * is a dummy operation.
1109 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1111 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1117 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1118 struct file *dst_file, loff_t destoff,
1119 size_t len, unsigned int flags)
1121 unsigned int xid = get_xid();
1124 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1130 const struct file_operations cifs_file_ops = {
1131 .read_iter = cifs_loose_read_iter,
1132 .write_iter = cifs_file_write_iter,
1134 .release = cifs_close,
1136 .fsync = cifs_fsync,
1137 .flush = cifs_flush,
1138 .mmap = cifs_file_mmap,
1139 .splice_read = generic_file_splice_read,
1140 .splice_write = iter_file_splice_write,
1141 .llseek = cifs_llseek,
1142 .unlocked_ioctl = cifs_ioctl,
1143 .copy_file_range = cifs_copy_file_range,
1144 .clone_file_range = cifs_clone_file_range,
1145 .setlease = cifs_setlease,
1146 .fallocate = cifs_fallocate,
1149 const struct file_operations cifs_file_strict_ops = {
1150 .read_iter = cifs_strict_readv,
1151 .write_iter = cifs_strict_writev,
1153 .release = cifs_close,
1155 .fsync = cifs_strict_fsync,
1156 .flush = cifs_flush,
1157 .mmap = cifs_file_strict_mmap,
1158 .splice_read = generic_file_splice_read,
1159 .splice_write = iter_file_splice_write,
1160 .llseek = cifs_llseek,
1161 .unlocked_ioctl = cifs_ioctl,
1162 .copy_file_range = cifs_copy_file_range,
1163 .clone_file_range = cifs_clone_file_range,
1164 .setlease = cifs_setlease,
1165 .fallocate = cifs_fallocate,
1168 const struct file_operations cifs_file_direct_ops = {
1169 /* BB reevaluate whether they can be done with directio, no cache */
1170 .read_iter = cifs_user_readv,
1171 .write_iter = cifs_user_writev,
1173 .release = cifs_close,
1175 .fsync = cifs_fsync,
1176 .flush = cifs_flush,
1177 .mmap = cifs_file_mmap,
1178 .splice_read = generic_file_splice_read,
1179 .splice_write = iter_file_splice_write,
1180 .unlocked_ioctl = cifs_ioctl,
1181 .copy_file_range = cifs_copy_file_range,
1182 .clone_file_range = cifs_clone_file_range,
1183 .llseek = cifs_llseek,
1184 .setlease = cifs_setlease,
1185 .fallocate = cifs_fallocate,
1188 const struct file_operations cifs_file_nobrl_ops = {
1189 .read_iter = cifs_loose_read_iter,
1190 .write_iter = cifs_file_write_iter,
1192 .release = cifs_close,
1193 .fsync = cifs_fsync,
1194 .flush = cifs_flush,
1195 .mmap = cifs_file_mmap,
1196 .splice_read = generic_file_splice_read,
1197 .splice_write = iter_file_splice_write,
1198 .llseek = cifs_llseek,
1199 .unlocked_ioctl = cifs_ioctl,
1200 .copy_file_range = cifs_copy_file_range,
1201 .clone_file_range = cifs_clone_file_range,
1202 .setlease = cifs_setlease,
1203 .fallocate = cifs_fallocate,
1206 const struct file_operations cifs_file_strict_nobrl_ops = {
1207 .read_iter = cifs_strict_readv,
1208 .write_iter = cifs_strict_writev,
1210 .release = cifs_close,
1211 .fsync = cifs_strict_fsync,
1212 .flush = cifs_flush,
1213 .mmap = cifs_file_strict_mmap,
1214 .splice_read = generic_file_splice_read,
1215 .splice_write = iter_file_splice_write,
1216 .llseek = cifs_llseek,
1217 .unlocked_ioctl = cifs_ioctl,
1218 .copy_file_range = cifs_copy_file_range,
1219 .clone_file_range = cifs_clone_file_range,
1220 .setlease = cifs_setlease,
1221 .fallocate = cifs_fallocate,
1224 const struct file_operations cifs_file_direct_nobrl_ops = {
1225 /* BB reevaluate whether they can be done with directio, no cache */
1226 .read_iter = cifs_user_readv,
1227 .write_iter = cifs_user_writev,
1229 .release = cifs_close,
1230 .fsync = cifs_fsync,
1231 .flush = cifs_flush,
1232 .mmap = cifs_file_mmap,
1233 .splice_read = generic_file_splice_read,
1234 .splice_write = iter_file_splice_write,
1235 .unlocked_ioctl = cifs_ioctl,
1236 .copy_file_range = cifs_copy_file_range,
1237 .clone_file_range = cifs_clone_file_range,
1238 .llseek = cifs_llseek,
1239 .setlease = cifs_setlease,
1240 .fallocate = cifs_fallocate,
1243 const struct file_operations cifs_dir_ops = {
1244 .iterate_shared = cifs_readdir,
1245 .release = cifs_closedir,
1246 .read = generic_read_dir,
1247 .unlocked_ioctl = cifs_ioctl,
1248 .copy_file_range = cifs_copy_file_range,
1249 .clone_file_range = cifs_clone_file_range,
1250 .llseek = generic_file_llseek,
1251 .fsync = cifs_dir_fsync,
1255 cifs_init_once(void *inode)
1257 struct cifsInodeInfo *cifsi = inode;
1259 inode_init_once(&cifsi->vfs_inode);
1260 init_rwsem(&cifsi->lock_sem);
1264 cifs_init_inodecache(void)
1266 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1267 sizeof(struct cifsInodeInfo),
1268 0, (SLAB_RECLAIM_ACCOUNT|
1269 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1271 if (cifs_inode_cachep == NULL)
1278 cifs_destroy_inodecache(void)
1281 * Make sure all delayed rcu free inodes are flushed before we
1285 kmem_cache_destroy(cifs_inode_cachep);
1289 cifs_init_request_bufs(void)
1292 * SMB2 maximum header size is bigger than CIFS one - no problems to
1293 * allocate some more bytes for CIFS.
1295 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1297 if (CIFSMaxBufSize < 8192) {
1298 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1299 Unicode path name has to fit in any SMB/CIFS path based frames */
1300 CIFSMaxBufSize = 8192;
1301 } else if (CIFSMaxBufSize > 1024*127) {
1302 CIFSMaxBufSize = 1024 * 127;
1304 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1307 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1308 CIFSMaxBufSize, CIFSMaxBufSize);
1310 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1311 CIFSMaxBufSize + max_hdr_size, 0,
1312 SLAB_HWCACHE_ALIGN, 0,
1313 CIFSMaxBufSize + max_hdr_size,
1315 if (cifs_req_cachep == NULL)
1318 if (cifs_min_rcv < 1)
1320 else if (cifs_min_rcv > 64) {
1322 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1325 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1328 if (cifs_req_poolp == NULL) {
1329 kmem_cache_destroy(cifs_req_cachep);
1332 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1333 almost all handle based requests (but not write response, nor is it
1334 sufficient for path based requests). A smaller size would have
1335 been more efficient (compacting multiple slab items on one 4k page)
1336 for the case in which debug was on, but this larger size allows
1337 more SMBs to use small buffer alloc and is still much more
1338 efficient to alloc 1 per page off the slab compared to 17K (5page)
1339 alloc of large cifs buffers even when page debugging is on */
1340 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1341 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1342 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1343 if (cifs_sm_req_cachep == NULL) {
1344 mempool_destroy(cifs_req_poolp);
1345 kmem_cache_destroy(cifs_req_cachep);
1349 if (cifs_min_small < 2)
1351 else if (cifs_min_small > 256) {
1352 cifs_min_small = 256;
1353 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1356 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1357 cifs_sm_req_cachep);
1359 if (cifs_sm_req_poolp == NULL) {
1360 mempool_destroy(cifs_req_poolp);
1361 kmem_cache_destroy(cifs_req_cachep);
1362 kmem_cache_destroy(cifs_sm_req_cachep);
1370 cifs_destroy_request_bufs(void)
1372 mempool_destroy(cifs_req_poolp);
1373 kmem_cache_destroy(cifs_req_cachep);
1374 mempool_destroy(cifs_sm_req_poolp);
1375 kmem_cache_destroy(cifs_sm_req_cachep);
1379 cifs_init_mids(void)
1381 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1382 sizeof(struct mid_q_entry), 0,
1383 SLAB_HWCACHE_ALIGN, NULL);
1384 if (cifs_mid_cachep == NULL)
1387 /* 3 is a reasonable minimum number of simultaneous operations */
1388 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1389 if (cifs_mid_poolp == NULL) {
1390 kmem_cache_destroy(cifs_mid_cachep);
1398 cifs_destroy_mids(void)
1400 mempool_destroy(cifs_mid_poolp);
1401 kmem_cache_destroy(cifs_mid_cachep);
1409 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1410 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1411 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1412 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1413 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1415 * Initialize Global counters
1417 atomic_set(&sesInfoAllocCount, 0);
1418 atomic_set(&tconInfoAllocCount, 0);
1419 atomic_set(&tcpSesAllocCount, 0);
1420 atomic_set(&tcpSesReconnectCount, 0);
1421 atomic_set(&tconInfoReconnectCount, 0);
1423 atomic_set(&bufAllocCount, 0);
1424 atomic_set(&smBufAllocCount, 0);
1425 #ifdef CONFIG_CIFS_STATS2
1426 atomic_set(&totBufAllocCount, 0);
1427 atomic_set(&totSmBufAllocCount, 0);
1428 #endif /* CONFIG_CIFS_STATS2 */
1430 atomic_set(&midCount, 0);
1431 GlobalCurrentXid = 0;
1432 GlobalTotalActiveXid = 0;
1433 GlobalMaxActiveXid = 0;
1434 spin_lock_init(&cifs_tcp_ses_lock);
1435 spin_lock_init(&GlobalMid_Lock);
1437 cifs_lock_secret = get_random_u32();
1439 if (cifs_max_pending < 2) {
1440 cifs_max_pending = 2;
1441 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1442 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1443 cifs_max_pending = CIFS_MAX_REQ;
1444 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1448 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1451 goto out_clean_proc;
1454 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1455 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1456 if (!cifsoplockd_wq) {
1458 goto out_destroy_cifsiod_wq;
1461 rc = cifs_fscache_register();
1463 goto out_destroy_cifsoplockd_wq;
1465 rc = cifs_init_inodecache();
1467 goto out_unreg_fscache;
1469 rc = cifs_init_mids();
1471 goto out_destroy_inodecache;
1473 rc = cifs_init_request_bufs();
1475 goto out_destroy_mids;
1477 #ifdef CONFIG_CIFS_UPCALL
1478 rc = init_cifs_spnego();
1480 goto out_destroy_request_bufs;
1481 #endif /* CONFIG_CIFS_UPCALL */
1483 #ifdef CONFIG_CIFS_ACL
1484 rc = init_cifs_idmap();
1486 goto out_register_key_type;
1487 #endif /* CONFIG_CIFS_ACL */
1489 rc = register_filesystem(&cifs_fs_type);
1491 goto out_init_cifs_idmap;
1493 rc = register_filesystem(&smb3_fs_type);
1495 unregister_filesystem(&cifs_fs_type);
1496 goto out_init_cifs_idmap;
1501 out_init_cifs_idmap:
1502 #ifdef CONFIG_CIFS_ACL
1504 out_register_key_type:
1506 #ifdef CONFIG_CIFS_UPCALL
1508 out_destroy_request_bufs:
1510 cifs_destroy_request_bufs();
1512 cifs_destroy_mids();
1513 out_destroy_inodecache:
1514 cifs_destroy_inodecache();
1516 cifs_fscache_unregister();
1517 out_destroy_cifsoplockd_wq:
1518 destroy_workqueue(cifsoplockd_wq);
1519 out_destroy_cifsiod_wq:
1520 destroy_workqueue(cifsiod_wq);
1529 cifs_dbg(NOISY, "exit_smb3\n");
1530 unregister_filesystem(&cifs_fs_type);
1531 unregister_filesystem(&smb3_fs_type);
1532 cifs_dfs_release_automount_timer();
1533 #ifdef CONFIG_CIFS_ACL
1536 #ifdef CONFIG_CIFS_UPCALL
1539 cifs_destroy_request_bufs();
1540 cifs_destroy_mids();
1541 cifs_destroy_inodecache();
1542 cifs_fscache_unregister();
1543 destroy_workqueue(cifsoplockd_wq);
1544 destroy_workqueue(cifsiod_wq);
1548 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1549 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1551 ("VFS to access servers complying with the SNIA CIFS Specification "
1552 "e.g. Samba and Windows");
1553 MODULE_VERSION(CIFS_VERSION);
1554 MODULE_SOFTDEP("pre: arc4");
1555 MODULE_SOFTDEP("pre: des");
1556 MODULE_SOFTDEP("pre: ecb");
1557 MODULE_SOFTDEP("pre: hmac");
1558 MODULE_SOFTDEP("pre: md4");
1559 MODULE_SOFTDEP("pre: md5");
1560 MODULE_SOFTDEP("pre: nls");
1561 MODULE_SOFTDEP("pre: aes");
1562 MODULE_SOFTDEP("pre: cmac");
1563 MODULE_SOFTDEP("pre: sha256");
1564 MODULE_SOFTDEP("pre: sha512");
1565 MODULE_SOFTDEP("pre: aead2");
1566 MODULE_SOFTDEP("pre: ccm");
1567 module_init(init_cifs)
1568 module_exit(exit_cifs)