Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: LGPL-2.1
0002 /*
0003  *
0004  *   Copyright (C) International Business Machines  Corp., 2002,2008
0005  *   Author(s): Steve French (sfrench@us.ibm.com)
0006  *
0007  *   Common Internet FileSystem (CIFS) client
0008  *
0009  */
0010 
0011 /* Note that BB means BUGBUG (ie something to fix eventually) */
0012 
0013 #include <linux/module.h>
0014 #include <linux/fs.h>
0015 #include <linux/mount.h>
0016 #include <linux/slab.h>
0017 #include <linux/init.h>
0018 #include <linux/list.h>
0019 #include <linux/seq_file.h>
0020 #include <linux/vfs.h>
0021 #include <linux/mempool.h>
0022 #include <linux/delay.h>
0023 #include <linux/kthread.h>
0024 #include <linux/freezer.h>
0025 #include <linux/namei.h>
0026 #include <linux/random.h>
0027 #include <linux/uuid.h>
0028 #include <linux/xattr.h>
0029 #include <uapi/linux/magic.h>
0030 #include <net/ipv6.h>
0031 #include "cifsfs.h"
0032 #include "cifspdu.h"
0033 #define DECLARE_GLOBALS_HERE
0034 #include "cifsglob.h"
0035 #include "cifsproto.h"
0036 #include "cifs_debug.h"
0037 #include "cifs_fs_sb.h"
0038 #include <linux/mm.h>
0039 #include <linux/key-type.h>
0040 #include "cifs_spnego.h"
0041 #include "fscache.h"
0042 #ifdef CONFIG_CIFS_DFS_UPCALL
0043 #include "dfs_cache.h"
0044 #endif
0045 #ifdef CONFIG_CIFS_SWN_UPCALL
0046 #include "netlink.h"
0047 #endif
0048 #include "fs_context.h"
0049 #include "cached_dir.h"
0050 
0051 /*
0052  * DOS dates from 1980/1/1 through 2107/12/31
0053  * Protocol specifications indicate the range should be to 119, which
0054  * limits maximum year to 2099. But this range has not been checked.
0055  */
0056 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
0057 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
0058 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
0059 
0060 int cifsFYI = 0;
0061 bool traceSMB;
0062 bool enable_oplocks = true;
0063 bool linuxExtEnabled = true;
0064 bool lookupCacheEnabled = true;
0065 bool disable_legacy_dialects; /* false by default */
0066 bool enable_gcm_256 = true;
0067 bool require_gcm_256; /* false by default */
0068 bool enable_negotiate_signing; /* false by default */
0069 unsigned int global_secflags = CIFSSEC_DEF;
0070 /* unsigned int ntlmv2_support = 0; */
0071 unsigned int sign_CIFS_PDUs = 1;
0072 
0073 /*
0074  * Global transaction id (XID) information
0075  */
0076 unsigned int GlobalCurrentXid;  /* protected by GlobalMid_Sem */
0077 unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
0078 unsigned int GlobalMaxActiveXid;    /* prot by GlobalMid_Sem */
0079 spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */
0080 
0081 /*
0082  *  Global counters, updated atomically
0083  */
0084 atomic_t sesInfoAllocCount;
0085 atomic_t tconInfoAllocCount;
0086 atomic_t tcpSesNextId;
0087 atomic_t tcpSesAllocCount;
0088 atomic_t tcpSesReconnectCount;
0089 atomic_t tconInfoReconnectCount;
0090 
0091 atomic_t mid_count;
0092 atomic_t buf_alloc_count;
0093 atomic_t small_buf_alloc_count;
0094 #ifdef CONFIG_CIFS_STATS2
0095 atomic_t total_buf_alloc_count;
0096 atomic_t total_small_buf_alloc_count;
0097 #endif/* STATS2 */
0098 struct list_head    cifs_tcp_ses_list;
0099 spinlock_t      cifs_tcp_ses_lock;
0100 static const struct super_operations cifs_super_ops;
0101 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
0102 module_param(CIFSMaxBufSize, uint, 0444);
0103 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
0104                  "for CIFS requests. "
0105                  "Default: 16384 Range: 8192 to 130048");
0106 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
0107 module_param(cifs_min_rcv, uint, 0444);
0108 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
0109                 "1 to 64");
0110 unsigned int cifs_min_small = 30;
0111 module_param(cifs_min_small, uint, 0444);
0112 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
0113                  "Range: 2 to 256");
0114 unsigned int cifs_max_pending = CIFS_MAX_REQ;
0115 module_param(cifs_max_pending, uint, 0444);
0116 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
0117                    "CIFS/SMB1 dialect (N/A for SMB3) "
0118                    "Default: 32767 Range: 2 to 32767.");
0119 #ifdef CONFIG_CIFS_STATS2
0120 unsigned int slow_rsp_threshold = 1;
0121 module_param(slow_rsp_threshold, uint, 0644);
0122 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
0123                    "before logging that a response is delayed. "
0124                    "Default: 1 (if set to 0 disables msg).");
0125 #endif /* STATS2 */
0126 
0127 module_param(enable_oplocks, bool, 0644);
0128 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
0129 
0130 module_param(enable_gcm_256, bool, 0644);
0131 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
0132 
0133 module_param(require_gcm_256, bool, 0644);
0134 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
0135 
0136 module_param(enable_negotiate_signing, bool, 0644);
0137 MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
0138 
0139 module_param(disable_legacy_dialects, bool, 0644);
0140 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
0141                   "helpful to restrict the ability to "
0142                   "override the default dialects (SMB2.1, "
0143                   "SMB3 and SMB3.02) on mount with old "
0144                   "dialects (CIFS/SMB1 and SMB2) since "
0145                   "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
0146                   " and less secure. Default: n/N/0");
0147 
0148 extern mempool_t *cifs_sm_req_poolp;
0149 extern mempool_t *cifs_req_poolp;
0150 extern mempool_t *cifs_mid_poolp;
0151 
0152 struct workqueue_struct *cifsiod_wq;
0153 struct workqueue_struct *decrypt_wq;
0154 struct workqueue_struct *fileinfo_put_wq;
0155 struct workqueue_struct *cifsoplockd_wq;
0156 struct workqueue_struct *deferredclose_wq;
0157 __u32 cifs_lock_secret;
0158 
0159 /*
0160  * Bumps refcount for cifs super block.
0161  * Note that it should be only called if a referece to VFS super block is
0162  * already held, e.g. in open-type syscalls context. Otherwise it can race with
0163  * atomic_dec_and_test in deactivate_locked_super.
0164  */
0165 void
0166 cifs_sb_active(struct super_block *sb)
0167 {
0168     struct cifs_sb_info *server = CIFS_SB(sb);
0169 
0170     if (atomic_inc_return(&server->active) == 1)
0171         atomic_inc(&sb->s_active);
0172 }
0173 
0174 void
0175 cifs_sb_deactive(struct super_block *sb)
0176 {
0177     struct cifs_sb_info *server = CIFS_SB(sb);
0178 
0179     if (atomic_dec_and_test(&server->active))
0180         deactivate_super(sb);
0181 }
0182 
0183 static int
0184 cifs_read_super(struct super_block *sb)
0185 {
0186     struct inode *inode;
0187     struct cifs_sb_info *cifs_sb;
0188     struct cifs_tcon *tcon;
0189     struct timespec64 ts;
0190     int rc = 0;
0191 
0192     cifs_sb = CIFS_SB(sb);
0193     tcon = cifs_sb_master_tcon(cifs_sb);
0194 
0195     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
0196         sb->s_flags |= SB_POSIXACL;
0197 
0198     if (tcon->snapshot_time)
0199         sb->s_flags |= SB_RDONLY;
0200 
0201     if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
0202         sb->s_maxbytes = MAX_LFS_FILESIZE;
0203     else
0204         sb->s_maxbytes = MAX_NON_LFS;
0205 
0206     /*
0207      * Some very old servers like DOS and OS/2 used 2 second granularity
0208      * (while all current servers use 100ns granularity - see MS-DTYP)
0209      * but 1 second is the maximum allowed granularity for the VFS
0210      * so for old servers set time granularity to 1 second while for
0211      * everything else (current servers) set it to 100ns.
0212      */
0213     if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
0214         ((tcon->ses->capabilities &
0215           tcon->ses->server->vals->cap_nt_find) == 0) &&
0216         !tcon->unix_ext) {
0217         sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
0218         ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
0219         sb->s_time_min = ts.tv_sec;
0220         ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
0221                     cpu_to_le16(SMB_TIME_MAX), 0);
0222         sb->s_time_max = ts.tv_sec;
0223     } else {
0224         /*
0225          * Almost every server, including all SMB2+, uses DCE TIME
0226          * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
0227          */
0228         sb->s_time_gran = 100;
0229         ts = cifs_NTtimeToUnix(0);
0230         sb->s_time_min = ts.tv_sec;
0231         ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
0232         sb->s_time_max = ts.tv_sec;
0233     }
0234 
0235     sb->s_magic = CIFS_SUPER_MAGIC;
0236     sb->s_op = &cifs_super_ops;
0237     sb->s_xattr = cifs_xattr_handlers;
0238     rc = super_setup_bdi(sb);
0239     if (rc)
0240         goto out_no_root;
0241     /* tune readahead according to rsize if readahead size not set on mount */
0242     if (cifs_sb->ctx->rsize == 0)
0243         cifs_sb->ctx->rsize =
0244             tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);
0245     if (cifs_sb->ctx->rasize)
0246         sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
0247     else
0248         sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
0249 
0250     sb->s_blocksize = CIFS_MAX_MSGSIZE;
0251     sb->s_blocksize_bits = 14;  /* default 2**14 = CIFS_MAX_MSGSIZE */
0252     inode = cifs_root_iget(sb);
0253 
0254     if (IS_ERR(inode)) {
0255         rc = PTR_ERR(inode);
0256         goto out_no_root;
0257     }
0258 
0259     if (tcon->nocase)
0260         sb->s_d_op = &cifs_ci_dentry_ops;
0261     else
0262         sb->s_d_op = &cifs_dentry_ops;
0263 
0264     sb->s_root = d_make_root(inode);
0265     if (!sb->s_root) {
0266         rc = -ENOMEM;
0267         goto out_no_root;
0268     }
0269 
0270 #ifdef CONFIG_CIFS_NFSD_EXPORT
0271     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
0272         cifs_dbg(FYI, "export ops supported\n");
0273         sb->s_export_op = &cifs_export_ops;
0274     }
0275 #endif /* CONFIG_CIFS_NFSD_EXPORT */
0276 
0277     return 0;
0278 
0279 out_no_root:
0280     cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
0281     return rc;
0282 }
0283 
0284 static void cifs_kill_sb(struct super_block *sb)
0285 {
0286     struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
0287 
0288     /*
0289      * We ned to release all dentries for the cached directories
0290      * before we kill the sb.
0291      */
0292     if (cifs_sb->root) {
0293         close_all_cached_dirs(cifs_sb);
0294 
0295         /* finally release root dentry */
0296         dput(cifs_sb->root);
0297         cifs_sb->root = NULL;
0298     }
0299 
0300     kill_anon_super(sb);
0301     cifs_umount(cifs_sb);
0302 }
0303 
0304 static int
0305 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
0306 {
0307     struct super_block *sb = dentry->d_sb;
0308     struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
0309     struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
0310     struct TCP_Server_Info *server = tcon->ses->server;
0311     unsigned int xid;
0312     int rc = 0;
0313 
0314     xid = get_xid();
0315 
0316     if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
0317         buf->f_namelen =
0318                le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
0319     else
0320         buf->f_namelen = PATH_MAX;
0321 
0322     buf->f_fsid.val[0] = tcon->vol_serial_number;
0323     /* are using part of create time for more randomness, see man statfs */
0324     buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
0325 
0326     buf->f_files = 0;   /* undefined */
0327     buf->f_ffree = 0;   /* unlimited */
0328 
0329     if (server->ops->queryfs)
0330         rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
0331 
0332     free_xid(xid);
0333     return rc;
0334 }
0335 
0336 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
0337 {
0338     struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
0339     struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
0340     struct TCP_Server_Info *server = tcon->ses->server;
0341 
0342     if (server->ops->fallocate)
0343         return server->ops->fallocate(file, tcon, mode, off, len);
0344 
0345     return -EOPNOTSUPP;
0346 }
0347 
0348 static int cifs_permission(struct user_namespace *mnt_userns,
0349                struct inode *inode, int mask)
0350 {
0351     struct cifs_sb_info *cifs_sb;
0352 
0353     cifs_sb = CIFS_SB(inode->i_sb);
0354 
0355     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
0356         if ((mask & MAY_EXEC) && !execute_ok(inode))
0357             return -EACCES;
0358         else
0359             return 0;
0360     } else /* file mode might have been restricted at mount time
0361         on the client (above and beyond ACL on servers) for
0362         servers which do not support setting and viewing mode bits,
0363         so allowing client to check permissions is useful */
0364         return generic_permission(&init_user_ns, inode, mask);
0365 }
0366 
0367 static struct kmem_cache *cifs_inode_cachep;
0368 static struct kmem_cache *cifs_req_cachep;
0369 static struct kmem_cache *cifs_mid_cachep;
0370 static struct kmem_cache *cifs_sm_req_cachep;
0371 mempool_t *cifs_sm_req_poolp;
0372 mempool_t *cifs_req_poolp;
0373 mempool_t *cifs_mid_poolp;
0374 
0375 static struct inode *
0376 cifs_alloc_inode(struct super_block *sb)
0377 {
0378     struct cifsInodeInfo *cifs_inode;
0379     cifs_inode = alloc_inode_sb(sb, cifs_inode_cachep, GFP_KERNEL);
0380     if (!cifs_inode)
0381         return NULL;
0382     cifs_inode->cifsAttrs = 0x20;   /* default */
0383     cifs_inode->time = 0;
0384     /*
0385      * Until the file is open and we have gotten oplock info back from the
0386      * server, can not assume caching of file data or metadata.
0387      */
0388     cifs_set_oplock_level(cifs_inode, 0);
0389     cifs_inode->flags = 0;
0390     spin_lock_init(&cifs_inode->writers_lock);
0391     cifs_inode->writers = 0;
0392     cifs_inode->netfs.inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
0393     cifs_inode->server_eof = 0;
0394     cifs_inode->uniqueid = 0;
0395     cifs_inode->createtime = 0;
0396     cifs_inode->epoch = 0;
0397     spin_lock_init(&cifs_inode->open_file_lock);
0398     generate_random_uuid(cifs_inode->lease_key);
0399 
0400     /*
0401      * Can not set i_flags here - they get immediately overwritten to zero
0402      * by the VFS.
0403      */
0404     /* cifs_inode->netfs.inode.i_flags = S_NOATIME | S_NOCMTIME; */
0405     INIT_LIST_HEAD(&cifs_inode->openFileList);
0406     INIT_LIST_HEAD(&cifs_inode->llist);
0407     INIT_LIST_HEAD(&cifs_inode->deferred_closes);
0408     spin_lock_init(&cifs_inode->deferred_lock);
0409     return &cifs_inode->netfs.inode;
0410 }
0411 
0412 static void
0413 cifs_free_inode(struct inode *inode)
0414 {
0415     kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
0416 }
0417 
0418 static void
0419 cifs_evict_inode(struct inode *inode)
0420 {
0421     truncate_inode_pages_final(&inode->i_data);
0422     if (inode->i_state & I_PINNING_FSCACHE_WB)
0423         cifs_fscache_unuse_inode_cookie(inode, true);
0424     cifs_fscache_release_inode_cookie(inode);
0425     clear_inode(inode);
0426 }
0427 
0428 static void
0429 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
0430 {
0431     struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
0432     struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
0433 
0434     seq_puts(s, ",addr=");
0435 
0436     switch (server->dstaddr.ss_family) {
0437     case AF_INET:
0438         seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
0439         break;
0440     case AF_INET6:
0441         seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
0442         if (sa6->sin6_scope_id)
0443             seq_printf(s, "%%%u", sa6->sin6_scope_id);
0444         break;
0445     default:
0446         seq_puts(s, "(unknown)");
0447     }
0448     if (server->rdma)
0449         seq_puts(s, ",rdma");
0450 }
0451 
0452 static void
0453 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
0454 {
0455     if (ses->sectype == Unspecified) {
0456         if (ses->user_name == NULL)
0457             seq_puts(s, ",sec=none");
0458         return;
0459     }
0460 
0461     seq_puts(s, ",sec=");
0462 
0463     switch (ses->sectype) {
0464     case NTLMv2:
0465         seq_puts(s, "ntlmv2");
0466         break;
0467     case Kerberos:
0468         seq_puts(s, "krb5");
0469         break;
0470     case RawNTLMSSP:
0471         seq_puts(s, "ntlmssp");
0472         break;
0473     default:
0474         /* shouldn't ever happen */
0475         seq_puts(s, "unknown");
0476         break;
0477     }
0478 
0479     if (ses->sign)
0480         seq_puts(s, "i");
0481 
0482     if (ses->sectype == Kerberos)
0483         seq_printf(s, ",cruid=%u",
0484                from_kuid_munged(&init_user_ns, ses->cred_uid));
0485 }
0486 
0487 static void
0488 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
0489 {
0490     seq_puts(s, ",cache=");
0491 
0492     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
0493         seq_puts(s, "strict");
0494     else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
0495         seq_puts(s, "none");
0496     else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
0497         seq_puts(s, "singleclient"); /* assume only one client access */
0498     else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
0499         seq_puts(s, "ro"); /* read only caching assumed */
0500     else
0501         seq_puts(s, "loose");
0502 }
0503 
0504 /*
0505  * cifs_show_devname() is used so we show the mount device name with correct
0506  * format (e.g. forward slashes vs. back slashes) in /proc/mounts
0507  */
0508 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
0509 {
0510     struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
0511     char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
0512 
0513     if (devname == NULL)
0514         seq_puts(m, "none");
0515     else {
0516         convert_delimiter(devname, '/');
0517         /* escape all spaces in share names */
0518         seq_escape(m, devname, " \t");
0519         kfree(devname);
0520     }
0521     return 0;
0522 }
0523 
0524 /*
0525  * cifs_show_options() is for displaying mount options in /proc/mounts.
0526  * Not all settable options are displayed but most of the important
0527  * ones are.
0528  */
0529 static int
0530 cifs_show_options(struct seq_file *s, struct dentry *root)
0531 {
0532     struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
0533     struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
0534     struct sockaddr *srcaddr;
0535     srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
0536 
0537     seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
0538     cifs_show_security(s, tcon->ses);
0539     cifs_show_cache_flavor(s, cifs_sb);
0540 
0541     if (tcon->no_lease)
0542         seq_puts(s, ",nolease");
0543     if (cifs_sb->ctx->multiuser)
0544         seq_puts(s, ",multiuser");
0545     else if (tcon->ses->user_name)
0546         seq_show_option(s, "username", tcon->ses->user_name);
0547 
0548     if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
0549         seq_show_option(s, "domain", tcon->ses->domainName);
0550 
0551     if (srcaddr->sa_family != AF_UNSPEC) {
0552         struct sockaddr_in *saddr4;
0553         struct sockaddr_in6 *saddr6;
0554         saddr4 = (struct sockaddr_in *)srcaddr;
0555         saddr6 = (struct sockaddr_in6 *)srcaddr;
0556         if (srcaddr->sa_family == AF_INET6)
0557             seq_printf(s, ",srcaddr=%pI6c",
0558                    &saddr6->sin6_addr);
0559         else if (srcaddr->sa_family == AF_INET)
0560             seq_printf(s, ",srcaddr=%pI4",
0561                    &saddr4->sin_addr.s_addr);
0562         else
0563             seq_printf(s, ",srcaddr=BAD-AF:%i",
0564                    (int)(srcaddr->sa_family));
0565     }
0566 
0567     seq_printf(s, ",uid=%u",
0568            from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
0569     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
0570         seq_puts(s, ",forceuid");
0571     else
0572         seq_puts(s, ",noforceuid");
0573 
0574     seq_printf(s, ",gid=%u",
0575            from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
0576     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
0577         seq_puts(s, ",forcegid");
0578     else
0579         seq_puts(s, ",noforcegid");
0580 
0581     cifs_show_address(s, tcon->ses->server);
0582 
0583     if (!tcon->unix_ext)
0584         seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
0585                        cifs_sb->ctx->file_mode,
0586                        cifs_sb->ctx->dir_mode);
0587     if (cifs_sb->ctx->iocharset)
0588         seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
0589     if (tcon->seal)
0590         seq_puts(s, ",seal");
0591     else if (tcon->ses->server->ignore_signature)
0592         seq_puts(s, ",signloosely");
0593     if (tcon->nocase)
0594         seq_puts(s, ",nocase");
0595     if (tcon->nodelete)
0596         seq_puts(s, ",nodelete");
0597     if (cifs_sb->ctx->no_sparse)
0598         seq_puts(s, ",nosparse");
0599     if (tcon->local_lease)
0600         seq_puts(s, ",locallease");
0601     if (tcon->retry)
0602         seq_puts(s, ",hard");
0603     else
0604         seq_puts(s, ",soft");
0605     if (tcon->use_persistent)
0606         seq_puts(s, ",persistenthandles");
0607     else if (tcon->use_resilient)
0608         seq_puts(s, ",resilienthandles");
0609     if (tcon->posix_extensions)
0610         seq_puts(s, ",posix");
0611     else if (tcon->unix_ext)
0612         seq_puts(s, ",unix");
0613     else
0614         seq_puts(s, ",nounix");
0615     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
0616         seq_puts(s, ",nodfs");
0617     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
0618         seq_puts(s, ",posixpaths");
0619     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
0620         seq_puts(s, ",setuids");
0621     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
0622         seq_puts(s, ",idsfromsid");
0623     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
0624         seq_puts(s, ",serverino");
0625     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
0626         seq_puts(s, ",rwpidforward");
0627     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
0628         seq_puts(s, ",forcemand");
0629     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
0630         seq_puts(s, ",nouser_xattr");
0631     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
0632         seq_puts(s, ",mapchars");
0633     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
0634         seq_puts(s, ",mapposix");
0635     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
0636         seq_puts(s, ",sfu");
0637     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
0638         seq_puts(s, ",nobrl");
0639     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
0640         seq_puts(s, ",nohandlecache");
0641     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
0642         seq_puts(s, ",modefromsid");
0643     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
0644         seq_puts(s, ",cifsacl");
0645     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
0646         seq_puts(s, ",dynperm");
0647     if (root->d_sb->s_flags & SB_POSIXACL)
0648         seq_puts(s, ",acl");
0649     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
0650         seq_puts(s, ",mfsymlinks");
0651     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
0652         seq_puts(s, ",fsc");
0653     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
0654         seq_puts(s, ",nostrictsync");
0655     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
0656         seq_puts(s, ",noperm");
0657     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
0658         seq_printf(s, ",backupuid=%u",
0659                from_kuid_munged(&init_user_ns,
0660                         cifs_sb->ctx->backupuid));
0661     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
0662         seq_printf(s, ",backupgid=%u",
0663                from_kgid_munged(&init_user_ns,
0664                         cifs_sb->ctx->backupgid));
0665 
0666     seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
0667     seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
0668     seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
0669     if (cifs_sb->ctx->rasize)
0670         seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
0671     if (tcon->ses->server->min_offload)
0672         seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
0673     seq_printf(s, ",echo_interval=%lu",
0674             tcon->ses->server->echo_interval / HZ);
0675 
0676     /* Only display max_credits if it was overridden on mount */
0677     if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
0678         seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
0679 
0680     if (tcon->snapshot_time)
0681         seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
0682     if (tcon->handle_timeout)
0683         seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
0684 
0685     /*
0686      * Display file and directory attribute timeout in seconds.
0687      * If file and directory attribute timeout the same then actimeo
0688      * was likely specified on mount
0689      */
0690     if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
0691         seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
0692     else {
0693         seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
0694         seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
0695     }
0696     seq_printf(s, ",closetimeo=%lu", cifs_sb->ctx->closetimeo / HZ);
0697 
0698     if (tcon->ses->chan_max > 1)
0699         seq_printf(s, ",multichannel,max_channels=%zu",
0700                tcon->ses->chan_max);
0701 
0702     if (tcon->use_witness)
0703         seq_puts(s, ",witness");
0704 
0705     return 0;
0706 }
0707 
0708 static void cifs_umount_begin(struct super_block *sb)
0709 {
0710     struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
0711     struct cifs_tcon *tcon;
0712 
0713     if (cifs_sb == NULL)
0714         return;
0715 
0716     tcon = cifs_sb_master_tcon(cifs_sb);
0717 
0718     spin_lock(&cifs_tcp_ses_lock);
0719     spin_lock(&tcon->tc_lock);
0720     if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {
0721         /* we have other mounts to same share or we have
0722            already tried to force umount this and woken up
0723            all waiting network requests, nothing to do */
0724         spin_unlock(&tcon->tc_lock);
0725         spin_unlock(&cifs_tcp_ses_lock);
0726         return;
0727     } else if (tcon->tc_count == 1)
0728         tcon->status = TID_EXITING;
0729     spin_unlock(&tcon->tc_lock);
0730     spin_unlock(&cifs_tcp_ses_lock);
0731 
0732     /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
0733     /* cancel_notify_requests(tcon); */
0734     if (tcon->ses && tcon->ses->server) {
0735         cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
0736         wake_up_all(&tcon->ses->server->request_q);
0737         wake_up_all(&tcon->ses->server->response_q);
0738         msleep(1); /* yield */
0739         /* we have to kick the requests once more */
0740         wake_up_all(&tcon->ses->server->response_q);
0741         msleep(1);
0742     }
0743 
0744     return;
0745 }
0746 
0747 #ifdef CONFIG_CIFS_STATS2
0748 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
0749 {
0750     /* BB FIXME */
0751     return 0;
0752 }
0753 #endif
0754 
0755 static int cifs_write_inode(struct inode *inode, struct writeback_control *wbc)
0756 {
0757     fscache_unpin_writeback(wbc, cifs_inode_cookie(inode));
0758     return 0;
0759 }
0760 
0761 static int cifs_drop_inode(struct inode *inode)
0762 {
0763     struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
0764 
0765     /* no serverino => unconditional eviction */
0766     return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
0767         generic_drop_inode(inode);
0768 }
0769 
0770 static const struct super_operations cifs_super_ops = {
0771     .statfs = cifs_statfs,
0772     .alloc_inode = cifs_alloc_inode,
0773     .write_inode    = cifs_write_inode,
0774     .free_inode = cifs_free_inode,
0775     .drop_inode = cifs_drop_inode,
0776     .evict_inode    = cifs_evict_inode,
0777 /*  .show_path  = cifs_show_path, */ /* Would we ever need show path? */
0778     .show_devname   = cifs_show_devname,
0779 /*  .delete_inode   = cifs_delete_inode,  */  /* Do not need above
0780     function unless later we add lazy close of inodes or unless the
0781     kernel forgets to call us with the same number of releases (closes)
0782     as opens */
0783     .show_options = cifs_show_options,
0784     .umount_begin   = cifs_umount_begin,
0785 #ifdef CONFIG_CIFS_STATS2
0786     .show_stats = cifs_show_stats,
0787 #endif
0788 };
0789 
0790 /*
0791  * Get root dentry from superblock according to prefix path mount option.
0792  * Return dentry with refcount + 1 on success and NULL otherwise.
0793  */
0794 static struct dentry *
0795 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
0796 {
0797     struct dentry *dentry;
0798     struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
0799     char *full_path = NULL;
0800     char *s, *p;
0801     char sep;
0802 
0803     if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
0804         return dget(sb->s_root);
0805 
0806     full_path = cifs_build_path_to_root(ctx, cifs_sb,
0807                 cifs_sb_master_tcon(cifs_sb), 0);
0808     if (full_path == NULL)
0809         return ERR_PTR(-ENOMEM);
0810 
0811     cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
0812 
0813     sep = CIFS_DIR_SEP(cifs_sb);
0814     dentry = dget(sb->s_root);
0815     s = full_path;
0816 
0817     do {
0818         struct inode *dir = d_inode(dentry);
0819         struct dentry *child;
0820 
0821         if (!S_ISDIR(dir->i_mode)) {
0822             dput(dentry);
0823             dentry = ERR_PTR(-ENOTDIR);
0824             break;
0825         }
0826 
0827         /* skip separators */
0828         while (*s == sep)
0829             s++;
0830         if (!*s)
0831             break;
0832         p = s++;
0833         /* next separator */
0834         while (*s && *s != sep)
0835             s++;
0836 
0837         child = lookup_positive_unlocked(p, dentry, s - p);
0838         dput(dentry);
0839         dentry = child;
0840     } while (!IS_ERR(dentry));
0841     kfree(full_path);
0842     return dentry;
0843 }
0844 
0845 static int cifs_set_super(struct super_block *sb, void *data)
0846 {
0847     struct cifs_mnt_data *mnt_data = data;
0848     sb->s_fs_info = mnt_data->cifs_sb;
0849     return set_anon_super(sb, NULL);
0850 }
0851 
0852 struct dentry *
0853 cifs_smb3_do_mount(struct file_system_type *fs_type,
0854           int flags, struct smb3_fs_context *old_ctx)
0855 {
0856     int rc;
0857     struct super_block *sb = NULL;
0858     struct cifs_sb_info *cifs_sb = NULL;
0859     struct cifs_mnt_data mnt_data;
0860     struct dentry *root;
0861 
0862     /*
0863      * Prints in Kernel / CIFS log the attempted mount operation
0864      *  If CIFS_DEBUG && cifs_FYI
0865      */
0866     if (cifsFYI)
0867         cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
0868     else
0869         cifs_info("Attempting to mount %s\n", old_ctx->UNC);
0870 
0871     cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
0872     if (cifs_sb == NULL) {
0873         root = ERR_PTR(-ENOMEM);
0874         goto out;
0875     }
0876 
0877     cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
0878     if (!cifs_sb->ctx) {
0879         root = ERR_PTR(-ENOMEM);
0880         goto out;
0881     }
0882     rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
0883     if (rc) {
0884         root = ERR_PTR(rc);
0885         goto out;
0886     }
0887 
0888     rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
0889     if (rc) {
0890         root = ERR_PTR(rc);
0891         goto out;
0892     }
0893 
0894     rc = cifs_setup_cifs_sb(cifs_sb);
0895     if (rc) {
0896         root = ERR_PTR(rc);
0897         goto out;
0898     }
0899 
0900     rc = cifs_mount(cifs_sb, cifs_sb->ctx);
0901     if (rc) {
0902         if (!(flags & SB_SILENT))
0903             cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
0904                  rc);
0905         root = ERR_PTR(rc);
0906         goto out;
0907     }
0908 
0909     mnt_data.ctx = cifs_sb->ctx;
0910     mnt_data.cifs_sb = cifs_sb;
0911     mnt_data.flags = flags;
0912 
0913     /* BB should we make this contingent on mount parm? */
0914     flags |= SB_NODIRATIME | SB_NOATIME;
0915 
0916     sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
0917     if (IS_ERR(sb)) {
0918         root = ERR_CAST(sb);
0919         cifs_umount(cifs_sb);
0920         cifs_sb = NULL;
0921         goto out;
0922     }
0923 
0924     if (sb->s_root) {
0925         cifs_dbg(FYI, "Use existing superblock\n");
0926         cifs_umount(cifs_sb);
0927         cifs_sb = NULL;
0928     } else {
0929         rc = cifs_read_super(sb);
0930         if (rc) {
0931             root = ERR_PTR(rc);
0932             goto out_super;
0933         }
0934 
0935         sb->s_flags |= SB_ACTIVE;
0936     }
0937 
0938     root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
0939     if (IS_ERR(root))
0940         goto out_super;
0941 
0942     if (cifs_sb)
0943         cifs_sb->root = dget(root);
0944 
0945     cifs_dbg(FYI, "dentry root is: %p\n", root);
0946     return root;
0947 
0948 out_super:
0949     deactivate_locked_super(sb);
0950     return root;
0951 out:
0952     if (cifs_sb) {
0953         if (!sb || IS_ERR(sb)) {  /* otherwise kill_sb will handle */
0954             kfree(cifs_sb->prepath);
0955             smb3_cleanup_fs_context(cifs_sb->ctx);
0956             kfree(cifs_sb);
0957         }
0958     }
0959     return root;
0960 }
0961 
0962 
0963 static ssize_t
0964 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
0965 {
0966     ssize_t rc;
0967     struct inode *inode = file_inode(iocb->ki_filp);
0968 
0969     if (iocb->ki_flags & IOCB_DIRECT)
0970         return cifs_user_readv(iocb, iter);
0971 
0972     rc = cifs_revalidate_mapping(inode);
0973     if (rc)
0974         return rc;
0975 
0976     return generic_file_read_iter(iocb, iter);
0977 }
0978 
0979 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
0980 {
0981     struct inode *inode = file_inode(iocb->ki_filp);
0982     struct cifsInodeInfo *cinode = CIFS_I(inode);
0983     ssize_t written;
0984     int rc;
0985 
0986     if (iocb->ki_filp->f_flags & O_DIRECT) {
0987         written = cifs_user_writev(iocb, from);
0988         if (written > 0 && CIFS_CACHE_READ(cinode)) {
0989             cifs_zap_mapping(inode);
0990             cifs_dbg(FYI,
0991                  "Set no oplock for inode=%p after a write operation\n",
0992                  inode);
0993             cinode->oplock = 0;
0994         }
0995         return written;
0996     }
0997 
0998     written = cifs_get_writer(cinode);
0999     if (written)
1000         return written;
1001 
1002     written = generic_file_write_iter(iocb, from);
1003 
1004     if (CIFS_CACHE_WRITE(CIFS_I(inode)))
1005         goto out;
1006 
1007     rc = filemap_fdatawrite(inode->i_mapping);
1008     if (rc)
1009         cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
1010              rc, inode);
1011 
1012 out:
1013     cifs_put_writer(cinode);
1014     return written;
1015 }
1016 
1017 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1018 {
1019     struct cifsFileInfo *cfile = file->private_data;
1020     struct cifs_tcon *tcon;
1021 
1022     /*
1023      * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1024      * the cached file length
1025      */
1026     if (whence != SEEK_SET && whence != SEEK_CUR) {
1027         int rc;
1028         struct inode *inode = file_inode(file);
1029 
1030         /*
1031          * We need to be sure that all dirty pages are written and the
1032          * server has the newest file length.
1033          */
1034         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1035             inode->i_mapping->nrpages != 0) {
1036             rc = filemap_fdatawait(inode->i_mapping);
1037             if (rc) {
1038                 mapping_set_error(inode->i_mapping, rc);
1039                 return rc;
1040             }
1041         }
1042         /*
1043          * Some applications poll for the file length in this strange
1044          * way so we must seek to end on non-oplocked files by
1045          * setting the revalidate time to zero.
1046          */
1047         CIFS_I(inode)->time = 0;
1048 
1049         rc = cifs_revalidate_file_attr(file);
1050         if (rc < 0)
1051             return (loff_t)rc;
1052     }
1053     if (cfile && cfile->tlink) {
1054         tcon = tlink_tcon(cfile->tlink);
1055         if (tcon->ses->server->ops->llseek)
1056             return tcon->ses->server->ops->llseek(file, tcon,
1057                                   offset, whence);
1058     }
1059     return generic_file_llseek(file, offset, whence);
1060 }
1061 
1062 static int
1063 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1064 {
1065     /*
1066      * Note that this is called by vfs setlease with i_lock held to
1067      * protect *lease from going away.
1068      */
1069     struct inode *inode = file_inode(file);
1070     struct cifsFileInfo *cfile = file->private_data;
1071 
1072     if (!(S_ISREG(inode->i_mode)))
1073         return -EINVAL;
1074 
1075     /* Check if file is oplocked if this is request for new lease */
1076     if (arg == F_UNLCK ||
1077         ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1078         ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1079         return generic_setlease(file, arg, lease, priv);
1080     else if (tlink_tcon(cfile->tlink)->local_lease &&
1081          !CIFS_CACHE_READ(CIFS_I(inode)))
1082         /*
1083          * If the server claims to support oplock on this file, then we
1084          * still need to check oplock even if the local_lease mount
1085          * option is set, but there are servers which do not support
1086          * oplock for which this mount option may be useful if the user
1087          * knows that the file won't be changed on the server by anyone
1088          * else.
1089          */
1090         return generic_setlease(file, arg, lease, priv);
1091     else
1092         return -EAGAIN;
1093 }
1094 
1095 struct file_system_type cifs_fs_type = {
1096     .owner = THIS_MODULE,
1097     .name = "cifs",
1098     .init_fs_context = smb3_init_fs_context,
1099     .parameters = smb3_fs_parameters,
1100     .kill_sb = cifs_kill_sb,
1101     .fs_flags = FS_RENAME_DOES_D_MOVE,
1102 };
1103 MODULE_ALIAS_FS("cifs");
1104 
1105 struct file_system_type smb3_fs_type = {
1106     .owner = THIS_MODULE,
1107     .name = "smb3",
1108     .init_fs_context = smb3_init_fs_context,
1109     .parameters = smb3_fs_parameters,
1110     .kill_sb = cifs_kill_sb,
1111     .fs_flags = FS_RENAME_DOES_D_MOVE,
1112 };
1113 MODULE_ALIAS_FS("smb3");
1114 MODULE_ALIAS("smb3");
1115 
1116 const struct inode_operations cifs_dir_inode_ops = {
1117     .create = cifs_create,
1118     .atomic_open = cifs_atomic_open,
1119     .lookup = cifs_lookup,
1120     .getattr = cifs_getattr,
1121     .unlink = cifs_unlink,
1122     .link = cifs_hardlink,
1123     .mkdir = cifs_mkdir,
1124     .rmdir = cifs_rmdir,
1125     .rename = cifs_rename2,
1126     .permission = cifs_permission,
1127     .setattr = cifs_setattr,
1128     .symlink = cifs_symlink,
1129     .mknod   = cifs_mknod,
1130     .listxattr = cifs_listxattr,
1131 };
1132 
1133 const struct inode_operations cifs_file_inode_ops = {
1134     .setattr = cifs_setattr,
1135     .getattr = cifs_getattr,
1136     .permission = cifs_permission,
1137     .listxattr = cifs_listxattr,
1138     .fiemap = cifs_fiemap,
1139 };
1140 
1141 const struct inode_operations cifs_symlink_inode_ops = {
1142     .get_link = cifs_get_link,
1143     .permission = cifs_permission,
1144     .listxattr = cifs_listxattr,
1145 };
1146 
1147 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1148         struct file *dst_file, loff_t destoff, loff_t len,
1149         unsigned int remap_flags)
1150 {
1151     struct inode *src_inode = file_inode(src_file);
1152     struct inode *target_inode = file_inode(dst_file);
1153     struct cifsFileInfo *smb_file_src = src_file->private_data;
1154     struct cifsFileInfo *smb_file_target;
1155     struct cifs_tcon *target_tcon;
1156     unsigned int xid;
1157     int rc;
1158 
1159     if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1160         return -EINVAL;
1161 
1162     cifs_dbg(FYI, "clone range\n");
1163 
1164     xid = get_xid();
1165 
1166     if (!src_file->private_data || !dst_file->private_data) {
1167         rc = -EBADF;
1168         cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1169         goto out;
1170     }
1171 
1172     smb_file_target = dst_file->private_data;
1173     target_tcon = tlink_tcon(smb_file_target->tlink);
1174 
1175     /*
1176      * Note: cifs case is easier than btrfs since server responsible for
1177      * checks for proper open modes and file type and if it wants
1178      * server could even support copy of range where source = target
1179      */
1180     lock_two_nondirectories(target_inode, src_inode);
1181 
1182     if (len == 0)
1183         len = src_inode->i_size - off;
1184 
1185     cifs_dbg(FYI, "about to flush pages\n");
1186     /* should we flush first and last page first */
1187     truncate_inode_pages_range(&target_inode->i_data, destoff,
1188                    PAGE_ALIGN(destoff + len)-1);
1189 
1190     if (target_tcon->ses->server->ops->duplicate_extents)
1191         rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1192             smb_file_src, smb_file_target, off, len, destoff);
1193     else
1194         rc = -EOPNOTSUPP;
1195 
1196     /* force revalidate of size and timestamps of target file now
1197        that target is updated on the server */
1198     CIFS_I(target_inode)->time = 0;
1199     /* although unlocking in the reverse order from locking is not
1200        strictly necessary here it is a little cleaner to be consistent */
1201     unlock_two_nondirectories(src_inode, target_inode);
1202 out:
1203     free_xid(xid);
1204     return rc < 0 ? rc : len;
1205 }
1206 
1207 ssize_t cifs_file_copychunk_range(unsigned int xid,
1208                 struct file *src_file, loff_t off,
1209                 struct file *dst_file, loff_t destoff,
1210                 size_t len, unsigned int flags)
1211 {
1212     struct inode *src_inode = file_inode(src_file);
1213     struct inode *target_inode = file_inode(dst_file);
1214     struct cifsFileInfo *smb_file_src;
1215     struct cifsFileInfo *smb_file_target;
1216     struct cifs_tcon *src_tcon;
1217     struct cifs_tcon *target_tcon;
1218     ssize_t rc;
1219 
1220     cifs_dbg(FYI, "copychunk range\n");
1221 
1222     if (!src_file->private_data || !dst_file->private_data) {
1223         rc = -EBADF;
1224         cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1225         goto out;
1226     }
1227 
1228     rc = -EXDEV;
1229     smb_file_target = dst_file->private_data;
1230     smb_file_src = src_file->private_data;
1231     src_tcon = tlink_tcon(smb_file_src->tlink);
1232     target_tcon = tlink_tcon(smb_file_target->tlink);
1233 
1234     if (src_tcon->ses != target_tcon->ses) {
1235         cifs_dbg(VFS, "source and target of copy not on same server\n");
1236         goto out;
1237     }
1238 
1239     rc = -EOPNOTSUPP;
1240     if (!target_tcon->ses->server->ops->copychunk_range)
1241         goto out;
1242 
1243     /*
1244      * Note: cifs case is easier than btrfs since server responsible for
1245      * checks for proper open modes and file type and if it wants
1246      * server could even support copy of range where source = target
1247      */
1248     lock_two_nondirectories(target_inode, src_inode);
1249 
1250     cifs_dbg(FYI, "about to flush pages\n");
1251 
1252     rc = filemap_write_and_wait_range(src_inode->i_mapping, off,
1253                       off + len - 1);
1254     if (rc)
1255         goto out;
1256 
1257     /* should we flush first and last page first */
1258     truncate_inode_pages(&target_inode->i_data, 0);
1259 
1260     rc = file_modified(dst_file);
1261     if (!rc)
1262         rc = target_tcon->ses->server->ops->copychunk_range(xid,
1263             smb_file_src, smb_file_target, off, len, destoff);
1264 
1265     file_accessed(src_file);
1266 
1267     /* force revalidate of size and timestamps of target file now
1268      * that target is updated on the server
1269      */
1270     CIFS_I(target_inode)->time = 0;
1271     /* although unlocking in the reverse order from locking is not
1272      * strictly necessary here it is a little cleaner to be consistent
1273      */
1274     unlock_two_nondirectories(src_inode, target_inode);
1275 
1276 out:
1277     return rc;
1278 }
1279 
1280 /*
1281  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1282  * is a dummy operation.
1283  */
1284 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1285 {
1286     cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1287          file, datasync);
1288 
1289     return 0;
1290 }
1291 
1292 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1293                 struct file *dst_file, loff_t destoff,
1294                 size_t len, unsigned int flags)
1295 {
1296     unsigned int xid = get_xid();
1297     ssize_t rc;
1298     struct cifsFileInfo *cfile = dst_file->private_data;
1299 
1300     if (cfile->swapfile)
1301         return -EOPNOTSUPP;
1302 
1303     rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1304                     len, flags);
1305     free_xid(xid);
1306 
1307     if (rc == -EOPNOTSUPP || rc == -EXDEV)
1308         rc = generic_copy_file_range(src_file, off, dst_file,
1309                          destoff, len, flags);
1310     return rc;
1311 }
1312 
1313 const struct file_operations cifs_file_ops = {
1314     .read_iter = cifs_loose_read_iter,
1315     .write_iter = cifs_file_write_iter,
1316     .open = cifs_open,
1317     .release = cifs_close,
1318     .lock = cifs_lock,
1319     .flock = cifs_flock,
1320     .fsync = cifs_fsync,
1321     .flush = cifs_flush,
1322     .mmap  = cifs_file_mmap,
1323     .splice_read = generic_file_splice_read,
1324     .splice_write = iter_file_splice_write,
1325     .llseek = cifs_llseek,
1326     .unlocked_ioctl = cifs_ioctl,
1327     .copy_file_range = cifs_copy_file_range,
1328     .remap_file_range = cifs_remap_file_range,
1329     .setlease = cifs_setlease,
1330     .fallocate = cifs_fallocate,
1331 };
1332 
1333 const struct file_operations cifs_file_strict_ops = {
1334     .read_iter = cifs_strict_readv,
1335     .write_iter = cifs_strict_writev,
1336     .open = cifs_open,
1337     .release = cifs_close,
1338     .lock = cifs_lock,
1339     .flock = cifs_flock,
1340     .fsync = cifs_strict_fsync,
1341     .flush = cifs_flush,
1342     .mmap = cifs_file_strict_mmap,
1343     .splice_read = generic_file_splice_read,
1344     .splice_write = iter_file_splice_write,
1345     .llseek = cifs_llseek,
1346     .unlocked_ioctl = cifs_ioctl,
1347     .copy_file_range = cifs_copy_file_range,
1348     .remap_file_range = cifs_remap_file_range,
1349     .setlease = cifs_setlease,
1350     .fallocate = cifs_fallocate,
1351 };
1352 
1353 const struct file_operations cifs_file_direct_ops = {
1354     .read_iter = cifs_direct_readv,
1355     .write_iter = cifs_direct_writev,
1356     .open = cifs_open,
1357     .release = cifs_close,
1358     .lock = cifs_lock,
1359     .flock = cifs_flock,
1360     .fsync = cifs_fsync,
1361     .flush = cifs_flush,
1362     .mmap = cifs_file_mmap,
1363     .splice_read = generic_file_splice_read,
1364     .splice_write = iter_file_splice_write,
1365     .unlocked_ioctl  = cifs_ioctl,
1366     .copy_file_range = cifs_copy_file_range,
1367     .remap_file_range = cifs_remap_file_range,
1368     .llseek = cifs_llseek,
1369     .setlease = cifs_setlease,
1370     .fallocate = cifs_fallocate,
1371 };
1372 
1373 const struct file_operations cifs_file_nobrl_ops = {
1374     .read_iter = cifs_loose_read_iter,
1375     .write_iter = cifs_file_write_iter,
1376     .open = cifs_open,
1377     .release = cifs_close,
1378     .fsync = cifs_fsync,
1379     .flush = cifs_flush,
1380     .mmap  = cifs_file_mmap,
1381     .splice_read = generic_file_splice_read,
1382     .splice_write = iter_file_splice_write,
1383     .llseek = cifs_llseek,
1384     .unlocked_ioctl = cifs_ioctl,
1385     .copy_file_range = cifs_copy_file_range,
1386     .remap_file_range = cifs_remap_file_range,
1387     .setlease = cifs_setlease,
1388     .fallocate = cifs_fallocate,
1389 };
1390 
1391 const struct file_operations cifs_file_strict_nobrl_ops = {
1392     .read_iter = cifs_strict_readv,
1393     .write_iter = cifs_strict_writev,
1394     .open = cifs_open,
1395     .release = cifs_close,
1396     .fsync = cifs_strict_fsync,
1397     .flush = cifs_flush,
1398     .mmap = cifs_file_strict_mmap,
1399     .splice_read = generic_file_splice_read,
1400     .splice_write = iter_file_splice_write,
1401     .llseek = cifs_llseek,
1402     .unlocked_ioctl = cifs_ioctl,
1403     .copy_file_range = cifs_copy_file_range,
1404     .remap_file_range = cifs_remap_file_range,
1405     .setlease = cifs_setlease,
1406     .fallocate = cifs_fallocate,
1407 };
1408 
1409 const struct file_operations cifs_file_direct_nobrl_ops = {
1410     .read_iter = cifs_direct_readv,
1411     .write_iter = cifs_direct_writev,
1412     .open = cifs_open,
1413     .release = cifs_close,
1414     .fsync = cifs_fsync,
1415     .flush = cifs_flush,
1416     .mmap = cifs_file_mmap,
1417     .splice_read = generic_file_splice_read,
1418     .splice_write = iter_file_splice_write,
1419     .unlocked_ioctl  = cifs_ioctl,
1420     .copy_file_range = cifs_copy_file_range,
1421     .remap_file_range = cifs_remap_file_range,
1422     .llseek = cifs_llseek,
1423     .setlease = cifs_setlease,
1424     .fallocate = cifs_fallocate,
1425 };
1426 
1427 const struct file_operations cifs_dir_ops = {
1428     .iterate_shared = cifs_readdir,
1429     .release = cifs_closedir,
1430     .read    = generic_read_dir,
1431     .unlocked_ioctl  = cifs_ioctl,
1432     .copy_file_range = cifs_copy_file_range,
1433     .remap_file_range = cifs_remap_file_range,
1434     .llseek = generic_file_llseek,
1435     .fsync = cifs_dir_fsync,
1436 };
1437 
1438 static void
1439 cifs_init_once(void *inode)
1440 {
1441     struct cifsInodeInfo *cifsi = inode;
1442 
1443     inode_init_once(&cifsi->netfs.inode);
1444     init_rwsem(&cifsi->lock_sem);
1445 }
1446 
1447 static int __init
1448 cifs_init_inodecache(void)
1449 {
1450     cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1451                           sizeof(struct cifsInodeInfo),
1452                           0, (SLAB_RECLAIM_ACCOUNT|
1453                         SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1454                           cifs_init_once);
1455     if (cifs_inode_cachep == NULL)
1456         return -ENOMEM;
1457 
1458     return 0;
1459 }
1460 
1461 static void
1462 cifs_destroy_inodecache(void)
1463 {
1464     /*
1465      * Make sure all delayed rcu free inodes are flushed before we
1466      * destroy cache.
1467      */
1468     rcu_barrier();
1469     kmem_cache_destroy(cifs_inode_cachep);
1470 }
1471 
1472 static int
1473 cifs_init_request_bufs(void)
1474 {
1475     /*
1476      * SMB2 maximum header size is bigger than CIFS one - no problems to
1477      * allocate some more bytes for CIFS.
1478      */
1479     size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1480 
1481     if (CIFSMaxBufSize < 8192) {
1482     /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1483     Unicode path name has to fit in any SMB/CIFS path based frames */
1484         CIFSMaxBufSize = 8192;
1485     } else if (CIFSMaxBufSize > 1024*127) {
1486         CIFSMaxBufSize = 1024 * 127;
1487     } else {
1488         CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1489     }
1490 /*
1491     cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1492          CIFSMaxBufSize, CIFSMaxBufSize);
1493 */
1494     cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1495                         CIFSMaxBufSize + max_hdr_size, 0,
1496                         SLAB_HWCACHE_ALIGN, 0,
1497                         CIFSMaxBufSize + max_hdr_size,
1498                         NULL);
1499     if (cifs_req_cachep == NULL)
1500         return -ENOMEM;
1501 
1502     if (cifs_min_rcv < 1)
1503         cifs_min_rcv = 1;
1504     else if (cifs_min_rcv > 64) {
1505         cifs_min_rcv = 64;
1506         cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1507     }
1508 
1509     cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1510                           cifs_req_cachep);
1511 
1512     if (cifs_req_poolp == NULL) {
1513         kmem_cache_destroy(cifs_req_cachep);
1514         return -ENOMEM;
1515     }
1516     /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1517     almost all handle based requests (but not write response, nor is it
1518     sufficient for path based requests).  A smaller size would have
1519     been more efficient (compacting multiple slab items on one 4k page)
1520     for the case in which debug was on, but this larger size allows
1521     more SMBs to use small buffer alloc and is still much more
1522     efficient to alloc 1 per page off the slab compared to 17K (5page)
1523     alloc of large cifs buffers even when page debugging is on */
1524     cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1525             MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1526             0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1527     if (cifs_sm_req_cachep == NULL) {
1528         mempool_destroy(cifs_req_poolp);
1529         kmem_cache_destroy(cifs_req_cachep);
1530         return -ENOMEM;
1531     }
1532 
1533     if (cifs_min_small < 2)
1534         cifs_min_small = 2;
1535     else if (cifs_min_small > 256) {
1536         cifs_min_small = 256;
1537         cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1538     }
1539 
1540     cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1541                              cifs_sm_req_cachep);
1542 
1543     if (cifs_sm_req_poolp == NULL) {
1544         mempool_destroy(cifs_req_poolp);
1545         kmem_cache_destroy(cifs_req_cachep);
1546         kmem_cache_destroy(cifs_sm_req_cachep);
1547         return -ENOMEM;
1548     }
1549 
1550     return 0;
1551 }
1552 
1553 static void
1554 cifs_destroy_request_bufs(void)
1555 {
1556     mempool_destroy(cifs_req_poolp);
1557     kmem_cache_destroy(cifs_req_cachep);
1558     mempool_destroy(cifs_sm_req_poolp);
1559     kmem_cache_destroy(cifs_sm_req_cachep);
1560 }
1561 
1562 static int init_mids(void)
1563 {
1564     cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1565                         sizeof(struct mid_q_entry), 0,
1566                         SLAB_HWCACHE_ALIGN, NULL);
1567     if (cifs_mid_cachep == NULL)
1568         return -ENOMEM;
1569 
1570     /* 3 is a reasonable minimum number of simultaneous operations */
1571     cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1572     if (cifs_mid_poolp == NULL) {
1573         kmem_cache_destroy(cifs_mid_cachep);
1574         return -ENOMEM;
1575     }
1576 
1577     return 0;
1578 }
1579 
1580 static void destroy_mids(void)
1581 {
1582     mempool_destroy(cifs_mid_poolp);
1583     kmem_cache_destroy(cifs_mid_cachep);
1584 }
1585 
1586 static int __init
1587 init_cifs(void)
1588 {
1589     int rc = 0;
1590     cifs_proc_init();
1591     INIT_LIST_HEAD(&cifs_tcp_ses_list);
1592 /*
1593  *  Initialize Global counters
1594  */
1595     atomic_set(&sesInfoAllocCount, 0);
1596     atomic_set(&tconInfoAllocCount, 0);
1597     atomic_set(&tcpSesNextId, 0);
1598     atomic_set(&tcpSesAllocCount, 0);
1599     atomic_set(&tcpSesReconnectCount, 0);
1600     atomic_set(&tconInfoReconnectCount, 0);
1601 
1602     atomic_set(&buf_alloc_count, 0);
1603     atomic_set(&small_buf_alloc_count, 0);
1604 #ifdef CONFIG_CIFS_STATS2
1605     atomic_set(&total_buf_alloc_count, 0);
1606     atomic_set(&total_small_buf_alloc_count, 0);
1607     if (slow_rsp_threshold < 1)
1608         cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1609     else if (slow_rsp_threshold > 32767)
1610         cifs_dbg(VFS,
1611                "slow response threshold set higher than recommended (0 to 32767)\n");
1612 #endif /* CONFIG_CIFS_STATS2 */
1613 
1614     atomic_set(&mid_count, 0);
1615     GlobalCurrentXid = 0;
1616     GlobalTotalActiveXid = 0;
1617     GlobalMaxActiveXid = 0;
1618     spin_lock_init(&cifs_tcp_ses_lock);
1619     spin_lock_init(&GlobalMid_Lock);
1620 
1621     cifs_lock_secret = get_random_u32();
1622 
1623     if (cifs_max_pending < 2) {
1624         cifs_max_pending = 2;
1625         cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1626     } else if (cifs_max_pending > CIFS_MAX_REQ) {
1627         cifs_max_pending = CIFS_MAX_REQ;
1628         cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1629              CIFS_MAX_REQ);
1630     }
1631 
1632     cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1633     if (!cifsiod_wq) {
1634         rc = -ENOMEM;
1635         goto out_clean_proc;
1636     }
1637 
1638     /*
1639      * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1640      * so that we don't launch too many worker threads but
1641      * Documentation/core-api/workqueue.rst recommends setting it to 0
1642      */
1643 
1644     /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1645     decrypt_wq = alloc_workqueue("smb3decryptd",
1646                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1647     if (!decrypt_wq) {
1648         rc = -ENOMEM;
1649         goto out_destroy_cifsiod_wq;
1650     }
1651 
1652     fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1653                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1654     if (!fileinfo_put_wq) {
1655         rc = -ENOMEM;
1656         goto out_destroy_decrypt_wq;
1657     }
1658 
1659     cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1660                      WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1661     if (!cifsoplockd_wq) {
1662         rc = -ENOMEM;
1663         goto out_destroy_fileinfo_put_wq;
1664     }
1665 
1666     deferredclose_wq = alloc_workqueue("deferredclose",
1667                        WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1668     if (!deferredclose_wq) {
1669         rc = -ENOMEM;
1670         goto out_destroy_cifsoplockd_wq;
1671     }
1672 
1673     rc = cifs_init_inodecache();
1674     if (rc)
1675         goto out_destroy_deferredclose_wq;
1676 
1677     rc = init_mids();
1678     if (rc)
1679         goto out_destroy_inodecache;
1680 
1681     rc = cifs_init_request_bufs();
1682     if (rc)
1683         goto out_destroy_mids;
1684 
1685 #ifdef CONFIG_CIFS_DFS_UPCALL
1686     rc = dfs_cache_init();
1687     if (rc)
1688         goto out_destroy_request_bufs;
1689 #endif /* CONFIG_CIFS_DFS_UPCALL */
1690 #ifdef CONFIG_CIFS_UPCALL
1691     rc = init_cifs_spnego();
1692     if (rc)
1693         goto out_destroy_dfs_cache;
1694 #endif /* CONFIG_CIFS_UPCALL */
1695 #ifdef CONFIG_CIFS_SWN_UPCALL
1696     rc = cifs_genl_init();
1697     if (rc)
1698         goto out_register_key_type;
1699 #endif /* CONFIG_CIFS_SWN_UPCALL */
1700 
1701     rc = init_cifs_idmap();
1702     if (rc)
1703         goto out_cifs_swn_init;
1704 
1705     rc = register_filesystem(&cifs_fs_type);
1706     if (rc)
1707         goto out_init_cifs_idmap;
1708 
1709     rc = register_filesystem(&smb3_fs_type);
1710     if (rc) {
1711         unregister_filesystem(&cifs_fs_type);
1712         goto out_init_cifs_idmap;
1713     }
1714 
1715     return 0;
1716 
1717 out_init_cifs_idmap:
1718     exit_cifs_idmap();
1719 out_cifs_swn_init:
1720 #ifdef CONFIG_CIFS_SWN_UPCALL
1721     cifs_genl_exit();
1722 out_register_key_type:
1723 #endif
1724 #ifdef CONFIG_CIFS_UPCALL
1725     exit_cifs_spnego();
1726 out_destroy_dfs_cache:
1727 #endif
1728 #ifdef CONFIG_CIFS_DFS_UPCALL
1729     dfs_cache_destroy();
1730 out_destroy_request_bufs:
1731 #endif
1732     cifs_destroy_request_bufs();
1733 out_destroy_mids:
1734     destroy_mids();
1735 out_destroy_inodecache:
1736     cifs_destroy_inodecache();
1737 out_destroy_deferredclose_wq:
1738     destroy_workqueue(deferredclose_wq);
1739 out_destroy_cifsoplockd_wq:
1740     destroy_workqueue(cifsoplockd_wq);
1741 out_destroy_fileinfo_put_wq:
1742     destroy_workqueue(fileinfo_put_wq);
1743 out_destroy_decrypt_wq:
1744     destroy_workqueue(decrypt_wq);
1745 out_destroy_cifsiod_wq:
1746     destroy_workqueue(cifsiod_wq);
1747 out_clean_proc:
1748     cifs_proc_clean();
1749     return rc;
1750 }
1751 
1752 static void __exit
1753 exit_cifs(void)
1754 {
1755     cifs_dbg(NOISY, "exit_smb3\n");
1756     unregister_filesystem(&cifs_fs_type);
1757     unregister_filesystem(&smb3_fs_type);
1758     cifs_dfs_release_automount_timer();
1759     exit_cifs_idmap();
1760 #ifdef CONFIG_CIFS_SWN_UPCALL
1761     cifs_genl_exit();
1762 #endif
1763 #ifdef CONFIG_CIFS_UPCALL
1764     exit_cifs_spnego();
1765 #endif
1766 #ifdef CONFIG_CIFS_DFS_UPCALL
1767     dfs_cache_destroy();
1768 #endif
1769     cifs_destroy_request_bufs();
1770     destroy_mids();
1771     cifs_destroy_inodecache();
1772     destroy_workqueue(deferredclose_wq);
1773     destroy_workqueue(cifsoplockd_wq);
1774     destroy_workqueue(decrypt_wq);
1775     destroy_workqueue(fileinfo_put_wq);
1776     destroy_workqueue(cifsiod_wq);
1777     cifs_proc_clean();
1778 }
1779 
1780 MODULE_AUTHOR("Steve French");
1781 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1782 MODULE_DESCRIPTION
1783     ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1784     "also older servers complying with the SNIA CIFS Specification)");
1785 MODULE_VERSION(CIFS_VERSION);
1786 MODULE_SOFTDEP("ecb");
1787 MODULE_SOFTDEP("hmac");
1788 MODULE_SOFTDEP("md5");
1789 MODULE_SOFTDEP("nls");
1790 MODULE_SOFTDEP("aes");
1791 MODULE_SOFTDEP("cmac");
1792 MODULE_SOFTDEP("sha256");
1793 MODULE_SOFTDEP("sha512");
1794 MODULE_SOFTDEP("aead2");
1795 MODULE_SOFTDEP("ccm");
1796 MODULE_SOFTDEP("gcm");
1797 module_init(init_cifs)
1798 module_exit(exit_cifs)
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!