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 generate_random_uuid(cifs_inode->lease_key);
298 * Can not set i_flags here - they get immediately overwritten to zero
301 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
302 INIT_LIST_HEAD(&cifs_inode->openFileList);
303 INIT_LIST_HEAD(&cifs_inode->llist);
304 return &cifs_inode->vfs_inode;
307 static void cifs_i_callback(struct rcu_head *head)
309 struct inode *inode = container_of(head, struct inode, i_rcu);
310 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
314 cifs_destroy_inode(struct inode *inode)
316 call_rcu(&inode->i_rcu, cifs_i_callback);
320 cifs_evict_inode(struct inode *inode)
322 truncate_inode_pages_final(&inode->i_data);
324 cifs_fscache_release_inode_cookie(inode);
328 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
330 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
331 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
333 seq_puts(s, ",addr=");
335 switch (server->dstaddr.ss_family) {
337 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
340 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
341 if (sa6->sin6_scope_id)
342 seq_printf(s, "%%%u", sa6->sin6_scope_id);
345 seq_puts(s, "(unknown)");
348 seq_puts(s, ",rdma");
352 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
354 if (ses->sectype == Unspecified) {
355 if (ses->user_name == NULL)
356 seq_puts(s, ",sec=none");
360 seq_puts(s, ",sec=");
362 switch (ses->sectype) {
364 seq_puts(s, "lanman");
367 seq_puts(s, "ntlmv2");
376 seq_puts(s, "ntlmssp");
379 /* shouldn't ever happen */
380 seq_puts(s, "unknown");
389 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
391 seq_puts(s, ",cache=");
393 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
394 seq_puts(s, "strict");
395 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
398 seq_puts(s, "loose");
402 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
404 struct nls_table *def;
406 /* Display iocharset= option if it's not default charset */
407 def = load_nls_default();
409 seq_printf(s, ",iocharset=%s", cur->charset);
414 * cifs_show_options() is for displaying mount options in /proc/mounts.
415 * Not all settable options are displayed but most of the important
419 cifs_show_options(struct seq_file *s, struct dentry *root)
421 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
422 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
423 struct sockaddr *srcaddr;
424 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
426 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
427 cifs_show_security(s, tcon->ses);
428 cifs_show_cache_flavor(s, cifs_sb);
430 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
431 seq_puts(s, ",multiuser");
432 else if (tcon->ses->user_name)
433 seq_show_option(s, "username", tcon->ses->user_name);
435 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
436 seq_show_option(s, "domain", tcon->ses->domainName);
438 if (srcaddr->sa_family != AF_UNSPEC) {
439 struct sockaddr_in *saddr4;
440 struct sockaddr_in6 *saddr6;
441 saddr4 = (struct sockaddr_in *)srcaddr;
442 saddr6 = (struct sockaddr_in6 *)srcaddr;
443 if (srcaddr->sa_family == AF_INET6)
444 seq_printf(s, ",srcaddr=%pI6c",
446 else if (srcaddr->sa_family == AF_INET)
447 seq_printf(s, ",srcaddr=%pI4",
448 &saddr4->sin_addr.s_addr);
450 seq_printf(s, ",srcaddr=BAD-AF:%i",
451 (int)(srcaddr->sa_family));
454 seq_printf(s, ",uid=%u",
455 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
456 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
457 seq_puts(s, ",forceuid");
459 seq_puts(s, ",noforceuid");
461 seq_printf(s, ",gid=%u",
462 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
463 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
464 seq_puts(s, ",forcegid");
466 seq_puts(s, ",noforcegid");
468 cifs_show_address(s, tcon->ses->server);
471 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
472 cifs_sb->mnt_file_mode,
473 cifs_sb->mnt_dir_mode);
475 cifs_show_nls(s, cifs_sb->local_nls);
478 seq_puts(s, ",seal");
480 seq_puts(s, ",nocase");
482 seq_puts(s, ",hard");
484 seq_puts(s, ",soft");
485 if (tcon->use_persistent)
486 seq_puts(s, ",persistenthandles");
487 else if (tcon->use_resilient)
488 seq_puts(s, ",resilienthandles");
489 if (tcon->posix_extensions)
490 seq_puts(s, ",posix");
491 else if (tcon->unix_ext)
492 seq_puts(s, ",unix");
494 seq_puts(s, ",nounix");
495 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
496 seq_puts(s, ",posixpaths");
497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
498 seq_puts(s, ",setuids");
499 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
500 seq_puts(s, ",idsfromsid");
501 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
502 seq_puts(s, ",serverino");
503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
504 seq_puts(s, ",rwpidforward");
505 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
506 seq_puts(s, ",forcemand");
507 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
508 seq_puts(s, ",nouser_xattr");
509 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
510 seq_puts(s, ",mapchars");
511 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
512 seq_puts(s, ",mapposix");
513 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
515 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
516 seq_puts(s, ",nobrl");
517 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
518 seq_puts(s, ",nohandlecache");
519 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
520 seq_puts(s, ",cifsacl");
521 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
522 seq_puts(s, ",dynperm");
523 if (root->d_sb->s_flags & SB_POSIXACL)
525 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
526 seq_puts(s, ",mfsymlinks");
527 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
529 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
530 seq_puts(s, ",nostrictsync");
531 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
532 seq_puts(s, ",noperm");
533 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
534 seq_printf(s, ",backupuid=%u",
535 from_kuid_munged(&init_user_ns,
536 cifs_sb->mnt_backupuid));
537 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
538 seq_printf(s, ",backupgid=%u",
539 from_kgid_munged(&init_user_ns,
540 cifs_sb->mnt_backupgid));
542 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
543 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
544 seq_printf(s, ",echo_interval=%lu",
545 tcon->ses->server->echo_interval / HZ);
546 if (tcon->snapshot_time)
547 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
548 /* convert actimeo and display it in seconds */
549 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
554 static void cifs_umount_begin(struct super_block *sb)
556 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
557 struct cifs_tcon *tcon;
562 tcon = cifs_sb_master_tcon(cifs_sb);
564 spin_lock(&cifs_tcp_ses_lock);
565 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
566 /* we have other mounts to same share or we have
567 already tried to force umount this and woken up
568 all waiting network requests, nothing to do */
569 spin_unlock(&cifs_tcp_ses_lock);
571 } else if (tcon->tc_count == 1)
572 tcon->tidStatus = CifsExiting;
573 spin_unlock(&cifs_tcp_ses_lock);
575 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
576 /* cancel_notify_requests(tcon); */
577 if (tcon->ses && tcon->ses->server) {
578 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
579 wake_up_all(&tcon->ses->server->request_q);
580 wake_up_all(&tcon->ses->server->response_q);
581 msleep(1); /* yield */
582 /* we have to kick the requests once more */
583 wake_up_all(&tcon->ses->server->response_q);
590 #ifdef CONFIG_CIFS_STATS2
591 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
598 static int cifs_remount(struct super_block *sb, int *flags, char *data)
601 *flags |= SB_NODIRATIME;
605 static int cifs_drop_inode(struct inode *inode)
607 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
609 /* no serverino => unconditional eviction */
610 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
611 generic_drop_inode(inode);
614 static const struct super_operations cifs_super_ops = {
615 .statfs = cifs_statfs,
616 .alloc_inode = cifs_alloc_inode,
617 .destroy_inode = cifs_destroy_inode,
618 .drop_inode = cifs_drop_inode,
619 .evict_inode = cifs_evict_inode,
620 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
621 function unless later we add lazy close of inodes or unless the
622 kernel forgets to call us with the same number of releases (closes)
624 .show_options = cifs_show_options,
625 .umount_begin = cifs_umount_begin,
626 .remount_fs = cifs_remount,
627 #ifdef CONFIG_CIFS_STATS2
628 .show_stats = cifs_show_stats,
633 * Get root dentry from superblock according to prefix path mount option.
634 * Return dentry with refcount + 1 on success and NULL otherwise.
636 static struct dentry *
637 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
639 struct dentry *dentry;
640 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
641 char *full_path = NULL;
645 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
646 return dget(sb->s_root);
648 full_path = cifs_build_path_to_root(vol, cifs_sb,
649 cifs_sb_master_tcon(cifs_sb), 0);
650 if (full_path == NULL)
651 return ERR_PTR(-ENOMEM);
653 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
655 sep = CIFS_DIR_SEP(cifs_sb);
656 dentry = dget(sb->s_root);
660 struct inode *dir = d_inode(dentry);
661 struct dentry *child;
665 dentry = ERR_PTR(-ENOENT);
668 if (!S_ISDIR(dir->i_mode)) {
670 dentry = ERR_PTR(-ENOTDIR);
674 /* skip separators */
681 while (*s && *s != sep)
684 child = lookup_one_len_unlocked(p, dentry, s - p);
687 } while (!IS_ERR(dentry));
692 static int cifs_set_super(struct super_block *sb, void *data)
694 struct cifs_mnt_data *mnt_data = data;
695 sb->s_fs_info = mnt_data->cifs_sb;
696 return set_anon_super(sb, NULL);
699 static struct dentry *
700 cifs_smb3_do_mount(struct file_system_type *fs_type,
701 int flags, const char *dev_name, void *data, bool is_smb3)
704 struct super_block *sb;
705 struct cifs_sb_info *cifs_sb;
706 struct smb_vol *volume_info;
707 struct cifs_mnt_data mnt_data;
710 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
712 volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
713 if (IS_ERR(volume_info))
714 return ERR_CAST(volume_info);
716 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
717 if (cifs_sb == NULL) {
718 root = ERR_PTR(-ENOMEM);
722 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
723 if (cifs_sb->mountdata == NULL) {
724 root = ERR_PTR(-ENOMEM);
728 rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
734 rc = cifs_mount(cifs_sb, volume_info);
736 if (!(flags & SB_SILENT))
737 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
743 mnt_data.vol = volume_info;
744 mnt_data.cifs_sb = cifs_sb;
745 mnt_data.flags = flags;
747 /* BB should we make this contingent on mount parm? */
748 flags |= SB_NODIRATIME | SB_NOATIME;
750 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
753 cifs_umount(cifs_sb);
758 cifs_dbg(FYI, "Use existing superblock\n");
759 cifs_umount(cifs_sb);
761 rc = cifs_read_super(sb);
767 sb->s_flags |= SB_ACTIVE;
770 root = cifs_get_root(volume_info, sb);
774 cifs_dbg(FYI, "dentry root is: %p\n", root);
778 deactivate_locked_super(sb);
780 cifs_cleanup_volume_info(volume_info);
784 kfree(cifs_sb->prepath);
785 kfree(cifs_sb->mountdata);
788 unload_nls(volume_info->local_nls);
792 static struct dentry *
793 smb3_do_mount(struct file_system_type *fs_type,
794 int flags, const char *dev_name, void *data)
796 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
799 static struct dentry *
800 cifs_do_mount(struct file_system_type *fs_type,
801 int flags, const char *dev_name, void *data)
803 return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
807 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
810 struct inode *inode = file_inode(iocb->ki_filp);
812 if (iocb->ki_filp->f_flags & O_DIRECT)
813 return cifs_user_readv(iocb, iter);
815 rc = cifs_revalidate_mapping(inode);
819 return generic_file_read_iter(iocb, iter);
822 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
824 struct inode *inode = file_inode(iocb->ki_filp);
825 struct cifsInodeInfo *cinode = CIFS_I(inode);
829 if (iocb->ki_filp->f_flags & O_DIRECT) {
830 written = cifs_user_writev(iocb, from);
831 if (written > 0 && CIFS_CACHE_READ(cinode)) {
832 cifs_zap_mapping(inode);
834 "Set no oplock for inode=%p after a write operation\n",
841 written = cifs_get_writer(cinode);
845 written = generic_file_write_iter(iocb, from);
847 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
850 rc = filemap_fdatawrite(inode->i_mapping);
852 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
856 cifs_put_writer(cinode);
860 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
863 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
864 * the cached file length
866 if (whence != SEEK_SET && whence != SEEK_CUR) {
868 struct inode *inode = file_inode(file);
871 * We need to be sure that all dirty pages are written and the
872 * server has the newest file length.
874 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
875 inode->i_mapping->nrpages != 0) {
876 rc = filemap_fdatawait(inode->i_mapping);
878 mapping_set_error(inode->i_mapping, rc);
883 * Some applications poll for the file length in this strange
884 * way so we must seek to end on non-oplocked files by
885 * setting the revalidate time to zero.
887 CIFS_I(inode)->time = 0;
889 rc = cifs_revalidate_file_attr(file);
893 return generic_file_llseek(file, offset, whence);
897 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
900 * Note that this is called by vfs setlease with i_lock held to
901 * protect *lease from going away.
903 struct inode *inode = file_inode(file);
904 struct cifsFileInfo *cfile = file->private_data;
906 if (!(S_ISREG(inode->i_mode)))
909 /* Check if file is oplocked if this is request for new lease */
910 if (arg == F_UNLCK ||
911 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
912 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
913 return generic_setlease(file, arg, lease, priv);
914 else if (tlink_tcon(cfile->tlink)->local_lease &&
915 !CIFS_CACHE_READ(CIFS_I(inode)))
917 * If the server claims to support oplock on this file, then we
918 * still need to check oplock even if the local_lease mount
919 * option is set, but there are servers which do not support
920 * oplock for which this mount option may be useful if the user
921 * knows that the file won't be changed on the server by anyone
924 return generic_setlease(file, arg, lease, priv);
929 struct file_system_type cifs_fs_type = {
930 .owner = THIS_MODULE,
932 .mount = cifs_do_mount,
933 .kill_sb = cifs_kill_sb,
936 MODULE_ALIAS_FS("cifs");
938 static struct file_system_type smb3_fs_type = {
939 .owner = THIS_MODULE,
941 .mount = smb3_do_mount,
942 .kill_sb = cifs_kill_sb,
945 MODULE_ALIAS_FS("smb3");
946 MODULE_ALIAS("smb3");
948 const struct inode_operations cifs_dir_inode_ops = {
949 .create = cifs_create,
950 .atomic_open = cifs_atomic_open,
951 .lookup = cifs_lookup,
952 .getattr = cifs_getattr,
953 .unlink = cifs_unlink,
954 .link = cifs_hardlink,
957 .rename = cifs_rename2,
958 .permission = cifs_permission,
959 .setattr = cifs_setattr,
960 .symlink = cifs_symlink,
962 .listxattr = cifs_listxattr,
965 const struct inode_operations cifs_file_inode_ops = {
966 .setattr = cifs_setattr,
967 .getattr = cifs_getattr,
968 .permission = cifs_permission,
969 .listxattr = cifs_listxattr,
972 const struct inode_operations cifs_symlink_inode_ops = {
973 .get_link = cifs_get_link,
974 .permission = cifs_permission,
975 .listxattr = cifs_listxattr,
978 static int cifs_clone_file_range(struct file *src_file, loff_t off,
979 struct file *dst_file, loff_t destoff, u64 len)
981 struct inode *src_inode = file_inode(src_file);
982 struct inode *target_inode = file_inode(dst_file);
983 struct cifsFileInfo *smb_file_src = src_file->private_data;
984 struct cifsFileInfo *smb_file_target;
985 struct cifs_tcon *target_tcon;
989 cifs_dbg(FYI, "clone range\n");
993 if (!src_file->private_data || !dst_file->private_data) {
995 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
999 smb_file_target = dst_file->private_data;
1000 target_tcon = tlink_tcon(smb_file_target->tlink);
1003 * Note: cifs case is easier than btrfs since server responsible for
1004 * checks for proper open modes and file type and if it wants
1005 * server could even support copy of range where source = target
1007 lock_two_nondirectories(target_inode, src_inode);
1010 len = src_inode->i_size - off;
1012 cifs_dbg(FYI, "about to flush pages\n");
1013 /* should we flush first and last page first */
1014 truncate_inode_pages_range(&target_inode->i_data, destoff,
1015 PAGE_ALIGN(destoff + len)-1);
1017 if (target_tcon->ses->server->ops->duplicate_extents)
1018 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1019 smb_file_src, smb_file_target, off, len, destoff);
1023 /* force revalidate of size and timestamps of target file now
1024 that target is updated on the server */
1025 CIFS_I(target_inode)->time = 0;
1026 /* although unlocking in the reverse order from locking is not
1027 strictly necessary here it is a little cleaner to be consistent */
1028 unlock_two_nondirectories(src_inode, target_inode);
1034 ssize_t cifs_file_copychunk_range(unsigned int xid,
1035 struct file *src_file, loff_t off,
1036 struct file *dst_file, loff_t destoff,
1037 size_t len, unsigned int flags)
1039 struct inode *src_inode = file_inode(src_file);
1040 struct inode *target_inode = file_inode(dst_file);
1041 struct cifsFileInfo *smb_file_src;
1042 struct cifsFileInfo *smb_file_target;
1043 struct cifs_tcon *src_tcon;
1044 struct cifs_tcon *target_tcon;
1047 cifs_dbg(FYI, "copychunk range\n");
1049 if (src_inode == target_inode) {
1054 if (!src_file->private_data || !dst_file->private_data) {
1056 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1061 smb_file_target = dst_file->private_data;
1062 smb_file_src = src_file->private_data;
1063 src_tcon = tlink_tcon(smb_file_src->tlink);
1064 target_tcon = tlink_tcon(smb_file_target->tlink);
1066 if (src_tcon->ses != target_tcon->ses) {
1067 cifs_dbg(VFS, "source and target of copy not on same server\n");
1072 * Note: cifs case is easier than btrfs since server responsible for
1073 * checks for proper open modes and file type and if it wants
1074 * server could even support copy of range where source = target
1076 lock_two_nondirectories(target_inode, src_inode);
1078 cifs_dbg(FYI, "about to flush pages\n");
1079 /* should we flush first and last page first */
1080 truncate_inode_pages(&target_inode->i_data, 0);
1082 if (target_tcon->ses->server->ops->copychunk_range)
1083 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1084 smb_file_src, smb_file_target, off, len, destoff);
1088 /* force revalidate of size and timestamps of target file now
1089 * that target is updated on the server
1091 CIFS_I(target_inode)->time = 0;
1092 /* although unlocking in the reverse order from locking is not
1093 * strictly necessary here it is a little cleaner to be consistent
1095 unlock_two_nondirectories(src_inode, target_inode);
1102 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1103 * is a dummy operation.
1105 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1107 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1113 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1114 struct file *dst_file, loff_t destoff,
1115 size_t len, unsigned int flags)
1117 unsigned int xid = get_xid();
1120 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1126 const struct file_operations cifs_file_ops = {
1127 .read_iter = cifs_loose_read_iter,
1128 .write_iter = cifs_file_write_iter,
1130 .release = cifs_close,
1132 .fsync = cifs_fsync,
1133 .flush = cifs_flush,
1134 .mmap = cifs_file_mmap,
1135 .splice_read = generic_file_splice_read,
1136 .splice_write = iter_file_splice_write,
1137 .llseek = cifs_llseek,
1138 .unlocked_ioctl = cifs_ioctl,
1139 .copy_file_range = cifs_copy_file_range,
1140 .clone_file_range = cifs_clone_file_range,
1141 .setlease = cifs_setlease,
1142 .fallocate = cifs_fallocate,
1145 const struct file_operations cifs_file_strict_ops = {
1146 .read_iter = cifs_strict_readv,
1147 .write_iter = cifs_strict_writev,
1149 .release = cifs_close,
1151 .fsync = cifs_strict_fsync,
1152 .flush = cifs_flush,
1153 .mmap = cifs_file_strict_mmap,
1154 .splice_read = generic_file_splice_read,
1155 .splice_write = iter_file_splice_write,
1156 .llseek = cifs_llseek,
1157 .unlocked_ioctl = cifs_ioctl,
1158 .copy_file_range = cifs_copy_file_range,
1159 .clone_file_range = cifs_clone_file_range,
1160 .setlease = cifs_setlease,
1161 .fallocate = cifs_fallocate,
1164 const struct file_operations cifs_file_direct_ops = {
1165 /* BB reevaluate whether they can be done with directio, no cache */
1166 .read_iter = cifs_user_readv,
1167 .write_iter = cifs_user_writev,
1169 .release = cifs_close,
1171 .fsync = cifs_fsync,
1172 .flush = cifs_flush,
1173 .mmap = cifs_file_mmap,
1174 .splice_read = generic_file_splice_read,
1175 .splice_write = iter_file_splice_write,
1176 .unlocked_ioctl = cifs_ioctl,
1177 .copy_file_range = cifs_copy_file_range,
1178 .clone_file_range = cifs_clone_file_range,
1179 .llseek = cifs_llseek,
1180 .setlease = cifs_setlease,
1181 .fallocate = cifs_fallocate,
1184 const struct file_operations cifs_file_nobrl_ops = {
1185 .read_iter = cifs_loose_read_iter,
1186 .write_iter = cifs_file_write_iter,
1188 .release = cifs_close,
1189 .fsync = cifs_fsync,
1190 .flush = cifs_flush,
1191 .mmap = cifs_file_mmap,
1192 .splice_read = generic_file_splice_read,
1193 .splice_write = iter_file_splice_write,
1194 .llseek = cifs_llseek,
1195 .unlocked_ioctl = cifs_ioctl,
1196 .copy_file_range = cifs_copy_file_range,
1197 .clone_file_range = cifs_clone_file_range,
1198 .setlease = cifs_setlease,
1199 .fallocate = cifs_fallocate,
1202 const struct file_operations cifs_file_strict_nobrl_ops = {
1203 .read_iter = cifs_strict_readv,
1204 .write_iter = cifs_strict_writev,
1206 .release = cifs_close,
1207 .fsync = cifs_strict_fsync,
1208 .flush = cifs_flush,
1209 .mmap = cifs_file_strict_mmap,
1210 .splice_read = generic_file_splice_read,
1211 .splice_write = iter_file_splice_write,
1212 .llseek = cifs_llseek,
1213 .unlocked_ioctl = cifs_ioctl,
1214 .copy_file_range = cifs_copy_file_range,
1215 .clone_file_range = cifs_clone_file_range,
1216 .setlease = cifs_setlease,
1217 .fallocate = cifs_fallocate,
1220 const struct file_operations cifs_file_direct_nobrl_ops = {
1221 /* BB reevaluate whether they can be done with directio, no cache */
1222 .read_iter = cifs_user_readv,
1223 .write_iter = cifs_user_writev,
1225 .release = cifs_close,
1226 .fsync = cifs_fsync,
1227 .flush = cifs_flush,
1228 .mmap = cifs_file_mmap,
1229 .splice_read = generic_file_splice_read,
1230 .splice_write = iter_file_splice_write,
1231 .unlocked_ioctl = cifs_ioctl,
1232 .copy_file_range = cifs_copy_file_range,
1233 .clone_file_range = cifs_clone_file_range,
1234 .llseek = cifs_llseek,
1235 .setlease = cifs_setlease,
1236 .fallocate = cifs_fallocate,
1239 const struct file_operations cifs_dir_ops = {
1240 .iterate_shared = cifs_readdir,
1241 .release = cifs_closedir,
1242 .read = generic_read_dir,
1243 .unlocked_ioctl = cifs_ioctl,
1244 .copy_file_range = cifs_copy_file_range,
1245 .clone_file_range = cifs_clone_file_range,
1246 .llseek = generic_file_llseek,
1247 .fsync = cifs_dir_fsync,
1251 cifs_init_once(void *inode)
1253 struct cifsInodeInfo *cifsi = inode;
1255 inode_init_once(&cifsi->vfs_inode);
1256 init_rwsem(&cifsi->lock_sem);
1260 cifs_init_inodecache(void)
1262 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1263 sizeof(struct cifsInodeInfo),
1264 0, (SLAB_RECLAIM_ACCOUNT|
1265 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1267 if (cifs_inode_cachep == NULL)
1274 cifs_destroy_inodecache(void)
1277 * Make sure all delayed rcu free inodes are flushed before we
1281 kmem_cache_destroy(cifs_inode_cachep);
1285 cifs_init_request_bufs(void)
1288 * SMB2 maximum header size is bigger than CIFS one - no problems to
1289 * allocate some more bytes for CIFS.
1291 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1293 if (CIFSMaxBufSize < 8192) {
1294 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1295 Unicode path name has to fit in any SMB/CIFS path based frames */
1296 CIFSMaxBufSize = 8192;
1297 } else if (CIFSMaxBufSize > 1024*127) {
1298 CIFSMaxBufSize = 1024 * 127;
1300 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1303 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1304 CIFSMaxBufSize, CIFSMaxBufSize);
1306 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1307 CIFSMaxBufSize + max_hdr_size, 0,
1308 SLAB_HWCACHE_ALIGN, 0,
1309 CIFSMaxBufSize + max_hdr_size,
1311 if (cifs_req_cachep == NULL)
1314 if (cifs_min_rcv < 1)
1316 else if (cifs_min_rcv > 64) {
1318 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1321 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1324 if (cifs_req_poolp == NULL) {
1325 kmem_cache_destroy(cifs_req_cachep);
1328 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1329 almost all handle based requests (but not write response, nor is it
1330 sufficient for path based requests). A smaller size would have
1331 been more efficient (compacting multiple slab items on one 4k page)
1332 for the case in which debug was on, but this larger size allows
1333 more SMBs to use small buffer alloc and is still much more
1334 efficient to alloc 1 per page off the slab compared to 17K (5page)
1335 alloc of large cifs buffers even when page debugging is on */
1336 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1337 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1338 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1339 if (cifs_sm_req_cachep == NULL) {
1340 mempool_destroy(cifs_req_poolp);
1341 kmem_cache_destroy(cifs_req_cachep);
1345 if (cifs_min_small < 2)
1347 else if (cifs_min_small > 256) {
1348 cifs_min_small = 256;
1349 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1352 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1353 cifs_sm_req_cachep);
1355 if (cifs_sm_req_poolp == NULL) {
1356 mempool_destroy(cifs_req_poolp);
1357 kmem_cache_destroy(cifs_req_cachep);
1358 kmem_cache_destroy(cifs_sm_req_cachep);
1366 cifs_destroy_request_bufs(void)
1368 mempool_destroy(cifs_req_poolp);
1369 kmem_cache_destroy(cifs_req_cachep);
1370 mempool_destroy(cifs_sm_req_poolp);
1371 kmem_cache_destroy(cifs_sm_req_cachep);
1375 cifs_init_mids(void)
1377 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1378 sizeof(struct mid_q_entry), 0,
1379 SLAB_HWCACHE_ALIGN, NULL);
1380 if (cifs_mid_cachep == NULL)
1383 /* 3 is a reasonable minimum number of simultaneous operations */
1384 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1385 if (cifs_mid_poolp == NULL) {
1386 kmem_cache_destroy(cifs_mid_cachep);
1394 cifs_destroy_mids(void)
1396 mempool_destroy(cifs_mid_poolp);
1397 kmem_cache_destroy(cifs_mid_cachep);
1405 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1406 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1407 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1408 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1409 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1411 * Initialize Global counters
1413 atomic_set(&sesInfoAllocCount, 0);
1414 atomic_set(&tconInfoAllocCount, 0);
1415 atomic_set(&tcpSesAllocCount, 0);
1416 atomic_set(&tcpSesReconnectCount, 0);
1417 atomic_set(&tconInfoReconnectCount, 0);
1419 atomic_set(&bufAllocCount, 0);
1420 atomic_set(&smBufAllocCount, 0);
1421 #ifdef CONFIG_CIFS_STATS2
1422 atomic_set(&totBufAllocCount, 0);
1423 atomic_set(&totSmBufAllocCount, 0);
1424 #endif /* CONFIG_CIFS_STATS2 */
1426 atomic_set(&midCount, 0);
1427 GlobalCurrentXid = 0;
1428 GlobalTotalActiveXid = 0;
1429 GlobalMaxActiveXid = 0;
1430 spin_lock_init(&cifs_tcp_ses_lock);
1431 spin_lock_init(&GlobalMid_Lock);
1433 cifs_lock_secret = get_random_u32();
1435 if (cifs_max_pending < 2) {
1436 cifs_max_pending = 2;
1437 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1438 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1439 cifs_max_pending = CIFS_MAX_REQ;
1440 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1444 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1447 goto out_clean_proc;
1450 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1451 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1452 if (!cifsoplockd_wq) {
1454 goto out_destroy_cifsiod_wq;
1457 rc = cifs_fscache_register();
1459 goto out_destroy_cifsoplockd_wq;
1461 rc = cifs_init_inodecache();
1463 goto out_unreg_fscache;
1465 rc = cifs_init_mids();
1467 goto out_destroy_inodecache;
1469 rc = cifs_init_request_bufs();
1471 goto out_destroy_mids;
1473 #ifdef CONFIG_CIFS_UPCALL
1474 rc = init_cifs_spnego();
1476 goto out_destroy_request_bufs;
1477 #endif /* CONFIG_CIFS_UPCALL */
1479 #ifdef CONFIG_CIFS_ACL
1480 rc = init_cifs_idmap();
1482 goto out_register_key_type;
1483 #endif /* CONFIG_CIFS_ACL */
1485 rc = register_filesystem(&cifs_fs_type);
1487 goto out_init_cifs_idmap;
1489 rc = register_filesystem(&smb3_fs_type);
1491 unregister_filesystem(&cifs_fs_type);
1492 goto out_init_cifs_idmap;
1497 out_init_cifs_idmap:
1498 #ifdef CONFIG_CIFS_ACL
1500 out_register_key_type:
1502 #ifdef CONFIG_CIFS_UPCALL
1504 out_destroy_request_bufs:
1506 cifs_destroy_request_bufs();
1508 cifs_destroy_mids();
1509 out_destroy_inodecache:
1510 cifs_destroy_inodecache();
1512 cifs_fscache_unregister();
1513 out_destroy_cifsoplockd_wq:
1514 destroy_workqueue(cifsoplockd_wq);
1515 out_destroy_cifsiod_wq:
1516 destroy_workqueue(cifsiod_wq);
1525 cifs_dbg(NOISY, "exit_smb3\n");
1526 unregister_filesystem(&cifs_fs_type);
1527 unregister_filesystem(&smb3_fs_type);
1528 cifs_dfs_release_automount_timer();
1529 #ifdef CONFIG_CIFS_ACL
1532 #ifdef CONFIG_CIFS_UPCALL
1535 cifs_destroy_request_bufs();
1536 cifs_destroy_mids();
1537 cifs_destroy_inodecache();
1538 cifs_fscache_unregister();
1539 destroy_workqueue(cifsoplockd_wq);
1540 destroy_workqueue(cifsiod_wq);
1544 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1545 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1547 ("VFS to access servers complying with the SNIA CIFS Specification "
1548 "e.g. Samba and Windows");
1549 MODULE_VERSION(CIFS_VERSION);
1550 MODULE_SOFTDEP("pre: arc4");
1551 MODULE_SOFTDEP("pre: des");
1552 MODULE_SOFTDEP("pre: ecb");
1553 MODULE_SOFTDEP("pre: hmac");
1554 MODULE_SOFTDEP("pre: md4");
1555 MODULE_SOFTDEP("pre: md5");
1556 MODULE_SOFTDEP("pre: nls");
1557 MODULE_SOFTDEP("pre: aes");
1558 MODULE_SOFTDEP("pre: cmac");
1559 MODULE_SOFTDEP("pre: sha256");
1560 MODULE_SOFTDEP("pre: sha512");
1561 MODULE_SOFTDEP("pre: aead2");
1562 MODULE_SOFTDEP("pre: ccm");
1563 module_init(init_cifs)
1564 module_exit(exit_cifs)