fs/cifs/cifsfs.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French ([email protected])
   6  *
   7  *   Common Internet FileSystem (CIFS) client
   8  *
   9  */
  10
  11 /* Note that BB means BUGBUG (ie something to fix eventually) */
  12
  13 #include <linux/module.h>
  14 #include <linux/fs.h>
  15 #include <linux/mount.h>
  16 #include <linux/slab.h>
  17 #include <linux/init.h>
  18 #include <linux/list.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/vfs.h>
  21 #include <linux/mempool.h>
  22 #include <linux/delay.h>
  23 #include <linux/kthread.h>
  24 #include <linux/freezer.h>
  25 #include <linux/namei.h>
  26 #include <linux/random.h>
  27 #include <linux/uuid.h>
  28 #include <linux/xattr.h>
  29 #include <uapi/linux/magic.h>
  30 #include <net/ipv6.h>
  31 #include "cifsfs.h"
  32 #include "cifspdu.h"
  33 #define DECLARE_GLOBALS_HERE
  34 #include "cifsglob.h"
  35 #include "cifsproto.h"
  36 #include "cifs_debug.h"
  37 #include "cifs_fs_sb.h"
  38 #include <linux/mm.h>
  39 #include <linux/key-type.h>
  40 #include "cifs_spnego.h"
  41 #include "fscache.h"
  42 #ifdef CONFIG_CIFS_DFS_UPCALL
  43 #include "dfs_cache.h"
  44 #endif
  45 #ifdef CONFIG_CIFS_SWN_UPCALL
  46 #include "netlink.h"
  47 #endif
  48 #include "fs_context.h"
  49
  50 /*
  51  * DOS dates from 1980/1/1 through 2107/12/31
  52  * Protocol specifications indicate the range should be to 119, which
  53  * limits maximum year to 2099. But this range has not been checked.
  54  */
  55 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
  56 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
  57 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
  58
  59 int cifsFYI = 0;
  60 bool traceSMB;
  61 bool enable_oplocks = true;
  62 bool linuxExtEnabled = true;
  63 bool lookupCacheEnabled = true;
  64 bool disable_legacy_dialects; /* false by default */
  65 bool enable_gcm_256 = true;
  66 bool require_gcm_256; /* false by default */
  67 bool enable_negotiate_signing; /* false by default */
  68 unsigned int global_secflags = CIFSSEC_DEF;
  69 /* unsigned int ntlmv2_support = 0; */
  70 unsigned int sign_CIFS_PDUs = 1;
  71 static const struct super_operations cifs_super_ops;
  72 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  73 module_param(CIFSMaxBufSize, uint, 0444);
  74 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
  75                                  "for CIFS requests. "
  76                                  "Default: 16384 Range: 8192 to 130048");
  77 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  78 module_param(cifs_min_rcv, uint, 0444);
  79 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  80                                 "1 to 64");
  81 unsigned int cifs_min_small = 30;
  82 module_param(cifs_min_small, uint, 0444);
  83 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  84                                  "Range: 2 to 256");
  85 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  86 module_param(cifs_max_pending, uint, 0444);
  87 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
  88                                    "CIFS/SMB1 dialect (N/A for SMB3) "
  89                                    "Default: 32767 Range: 2 to 32767.");
  90 #ifdef CONFIG_CIFS_STATS2
  91 unsigned int slow_rsp_threshold = 1;
  92 module_param(slow_rsp_threshold, uint, 0644);
  93 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
  94                                    "before logging that a response is delayed. "
  95                                    "Default: 1 (if set to 0 disables msg).");
  96 #endif /* STATS2 */
  97
  98 module_param(enable_oplocks, bool, 0644);
  99 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
 100
 101 module_param(enable_gcm_256, bool, 0644);
 102 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
 103
 104 module_param(require_gcm_256, bool, 0644);
 105 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
 106
 107 module_param(enable_negotiate_signing, bool, 0644);
 108 MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
 109
 110 module_param(disable_legacy_dialects, bool, 0644);
 111 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
 112                                   "helpful to restrict the ability to "
 113                                   "override the default dialects (SMB2.1, "
 114                                   "SMB3 and SMB3.02) on mount with old "
 115                                   "dialects (CIFS/SMB1 and SMB2) since "
 116                                   "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
 117                                   " and less secure. Default: n/N/0");
 118
 119 extern mempool_t *cifs_sm_req_poolp;
 120 extern mempool_t *cifs_req_poolp;
 121 extern mempool_t *cifs_mid_poolp;
 122
 123 struct workqueue_struct *cifsiod_wq;
 124 struct workqueue_struct *decrypt_wq;
 125 struct workqueue_struct *fileinfo_put_wq;
 126 struct workqueue_struct *cifsoplockd_wq;
 127 struct workqueue_struct *deferredclose_wq;
 128 __u32 cifs_lock_secret;
 129
 130 /*
 131  * Bumps refcount for cifs super block.
 132  * Note that it should be only called if a referece to VFS super block is
 133  * already held, e.g. in open-type syscalls context. Otherwise it can race with
 134  * atomic_dec_and_test in deactivate_locked_super.
 135  */
 136 void
 137 cifs_sb_active(struct super_block *sb)
 138 {
 139         struct cifs_sb_info *server = CIFS_SB(sb);
 140
 141         if (atomic_inc_return(&server->active) == 1)
 142                 atomic_inc(&sb->s_active);
 143 }
 144
 145 void
 146 cifs_sb_deactive(struct super_block *sb)
 147 {
 148         struct cifs_sb_info *server = CIFS_SB(sb);
 149
 150         if (atomic_dec_and_test(&server->active))
 151                 deactivate_super(sb);
 152 }
 153
 154 static int
 155 cifs_read_super(struct super_block *sb)
 156 {
 157         struct inode *inode;
 158         struct cifs_sb_info *cifs_sb;
 159         struct cifs_tcon *tcon;
 160         struct timespec64 ts;
 161         int rc = 0;
 162
 163         cifs_sb = CIFS_SB(sb);
 164         tcon = cifs_sb_master_tcon(cifs_sb);
 165
 166         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 167                 sb->s_flags |= SB_POSIXACL;
 168
 169         if (tcon->snapshot_time)
 170                 sb->s_flags |= SB_RDONLY;
 171
 172         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 173                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 174         else
 175                 sb->s_maxbytes = MAX_NON_LFS;
 176
 177         /*
 178          * Some very old servers like DOS and OS/2 used 2 second granularity
 179          * (while all current servers use 100ns granularity - see MS-DTYP)
 180          * but 1 second is the maximum allowed granularity for the VFS
 181          * so for old servers set time granularity to 1 second while for
 182          * everything else (current servers) set it to 100ns.
 183          */
 184         if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
 185             ((tcon->ses->capabilities &
 186               tcon->ses->server->vals->cap_nt_find) == 0) &&
 187             !tcon->unix_ext) {
 188                 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
 189                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
 190                 sb->s_time_min = ts.tv_sec;
 191                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
 192                                     cpu_to_le16(SMB_TIME_MAX), 0);
 193                 sb->s_time_max = ts.tv_sec;
 194         } else {
 195                 /*
 196                  * Almost every server, including all SMB2+, uses DCE TIME
 197                  * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
 198                  */
 199                 sb->s_time_gran = 100;
 200                 ts = cifs_NTtimeToUnix(0);
 201                 sb->s_time_min = ts.tv_sec;
 202                 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
 203                 sb->s_time_max = ts.tv_sec;
 204         }
 205
 206         sb->s_magic = CIFS_SUPER_MAGIC;
 207         sb->s_op = &cifs_super_ops;
 208         sb->s_xattr = cifs_xattr_handlers;
 209         rc = super_setup_bdi(sb);
 210         if (rc)
 211                 goto out_no_root;
 212         /* tune readahead according to rsize if readahead size not set on mount */
 213         if (cifs_sb->ctx->rsize == 0)
 214                 cifs_sb->ctx->rsize =
 215                         tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);
 216         if (cifs_sb->ctx->rasize)
 217                 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
 218         else
 219                 sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
 220
 221         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 222         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 223         inode = cifs_root_iget(sb);
 224
 225         if (IS_ERR(inode)) {
 226                 rc = PTR_ERR(inode);
 227                 goto out_no_root;
 228         }
 229
 230         if (tcon->nocase)
 231                 sb->s_d_op = &cifs_ci_dentry_ops;
 232         else
 233                 sb->s_d_op = &cifs_dentry_ops;
 234
 235         sb->s_root = d_make_root(inode);
 236         if (!sb->s_root) {
 237                 rc = -ENOMEM;
 238                 goto out_no_root;
 239         }
 240
 241 #ifdef CONFIG_CIFS_NFSD_EXPORT
 242         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 243                 cifs_dbg(FYI, "export ops supported\n");
 244                 sb->s_export_op = &cifs_export_ops;
 245         }
 246 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 247
 248         return 0;
 249
 250 out_no_root:
 251         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 252         return rc;
 253 }
 254
 255 static void cifs_kill_sb(struct super_block *sb)
 256 {
 257         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 258         struct cifs_tcon *tcon;
 259         struct cached_fid *cfid;
 260         struct rb_root *root = &cifs_sb->tlink_tree;
 261         struct rb_node *node;
 262         struct tcon_link *tlink;
 263
 264         /*
 265          * We ned to release all dentries for the cached directories
 266          * before we kill the sb.
 267          */
 268         if (cifs_sb->root) {
 269                 for (node = rb_first(root); node; node = rb_next(node)) {
 270                         tlink = rb_entry(node, struct tcon_link, tl_rbnode);
 271                         tcon = tlink_tcon(tlink);
 272                         if (IS_ERR(tcon))
 273                                 continue;
 274                         cfid = &tcon->crfid;
 275                         mutex_lock(&cfid->fid_mutex);
 276                         if (cfid->dentry) {
 277                                 dput(cfid->dentry);
 278                                 cfid->dentry = NULL;
 279                         }
 280                         mutex_unlock(&cfid->fid_mutex);
 281                 }
 282
 283                 /* finally release root dentry */
 284                 dput(cifs_sb->root);
 285                 cifs_sb->root = NULL;
 286         }
 287
 288         kill_anon_super(sb);
 289         cifs_umount(cifs_sb);
 290 }
 291
 292 static int
 293 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 294 {
 295         struct super_block *sb = dentry->d_sb;
 296         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 297         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 298         struct TCP_Server_Info *server = tcon->ses->server;
 299         unsigned int xid;
 300         int rc = 0;
 301
 302         xid = get_xid();
 303
 304         if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
 305                 buf->f_namelen =
 306                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
 307         else
 308                 buf->f_namelen = PATH_MAX;
 309
 310         buf->f_fsid.val[0] = tcon->vol_serial_number;
 311         /* are using part of create time for more randomness, see man statfs */
 312         buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
 313
 314         buf->f_files = 0;       /* undefined */
 315         buf->f_ffree = 0;       /* unlimited */
 316
 317         if (server->ops->queryfs)
 318                 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
 319
 320         free_xid(xid);
 321         return rc;
 322 }
 323
 324 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 325 {
 326         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 327         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 328         struct TCP_Server_Info *server = tcon->ses->server;
 329
 330         if (server->ops->fallocate)
 331                 return server->ops->fallocate(file, tcon, mode, off, len);
 332
 333         return -EOPNOTSUPP;
 334 }
 335
 336 static int cifs_permission(struct user_namespace *mnt_userns,
 337                            struct inode *inode, int mask)
 338 {
 339         struct cifs_sb_info *cifs_sb;
 340
 341         cifs_sb = CIFS_SB(inode->i_sb);
 342
 343         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 344                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 345                         return -EACCES;
 346                 else
 347                         return 0;
 348         } else /* file mode might have been restricted at mount time
 349                 on the client (above and beyond ACL on servers) for
 350                 servers which do not support setting and viewing mode bits,
 351                 so allowing client to check permissions is useful */
 352                 return generic_permission(&init_user_ns, inode, mask);
 353 }
 354
 355 static struct kmem_cache *cifs_inode_cachep;
 356 static struct kmem_cache *cifs_req_cachep;
 357 static struct kmem_cache *cifs_mid_cachep;
 358 static struct kmem_cache *cifs_sm_req_cachep;
 359 mempool_t *cifs_sm_req_poolp;
 360 mempool_t *cifs_req_poolp;
 361 mempool_t *cifs_mid_poolp;
 362
 363 static struct inode *
 364 cifs_alloc_inode(struct super_block *sb)
 365 {
 366         struct cifsInodeInfo *cifs_inode;
 367         cifs_inode = alloc_inode_sb(sb, cifs_inode_cachep, GFP_KERNEL);
 368         if (!cifs_inode)
 369                 return NULL;
 370         cifs_inode->cifsAttrs = 0x20;   /* default */
 371         cifs_inode->time = 0;
 372         /*
 373          * Until the file is open and we have gotten oplock info back from the
 374          * server, can not assume caching of file data or metadata.
 375          */
 376         cifs_set_oplock_level(cifs_inode, 0);
 377         cifs_inode->flags = 0;
 378         spin_lock_init(&cifs_inode->writers_lock);
 379         cifs_inode->writers = 0;
 380         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 381         cifs_inode->server_eof = 0;
 382         cifs_inode->uniqueid = 0;
 383         cifs_inode->createtime = 0;
 384         cifs_inode->epoch = 0;
 385         spin_lock_init(&cifs_inode->open_file_lock);
 386         generate_random_uuid(cifs_inode->lease_key);
 387
 388         /*
 389          * Can not set i_flags here - they get immediately overwritten to zero
 390          * by the VFS.
 391          */
 392         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 393         INIT_LIST_HEAD(&cifs_inode->openFileList);
 394         INIT_LIST_HEAD(&cifs_inode->llist);
 395         INIT_LIST_HEAD(&cifs_inode->deferred_closes);
 396         spin_lock_init(&cifs_inode->deferred_lock);
 397         return &cifs_inode->vfs_inode;
 398 }
 399
 400 static void
 401 cifs_free_inode(struct inode *inode)
 402 {
 403         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 404 }
 405
 406 static void
 407 cifs_evict_inode(struct inode *inode)
 408 {
 409         truncate_inode_pages_final(&inode->i_data);
 410         if (inode->i_state & I_PINNING_FSCACHE_WB)
 411                 cifs_fscache_unuse_inode_cookie(inode, true);
 412         cifs_fscache_release_inode_cookie(inode);
 413         clear_inode(inode);
 414 }
 415
 416 static void
 417 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 418 {
 419         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 420         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 421
 422         seq_puts(s, ",addr=");
 423
 424         switch (server->dstaddr.ss_family) {
 425         case AF_INET:
 426                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 427                 break;
 428         case AF_INET6:
 429                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 430                 if (sa6->sin6_scope_id)
 431                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 432                 break;
 433         default:
 434                 seq_puts(s, "(unknown)");
 435         }
 436         if (server->rdma)
 437                 seq_puts(s, ",rdma");
 438 }
 439
 440 static void
 441 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 442 {
 443         if (ses->sectype == Unspecified) {
 444                 if (ses->user_name == NULL)
 445                         seq_puts(s, ",sec=none");
 446                 return;
 447         }
 448
 449         seq_puts(s, ",sec=");
 450
 451         switch (ses->sectype) {
 452         case NTLMv2:
 453                 seq_puts(s, "ntlmv2");
 454                 break;
 455         case Kerberos:
 456                 seq_puts(s, "krb5");
 457                 break;
 458         case RawNTLMSSP:
 459                 seq_puts(s, "ntlmssp");
 460                 break;
 461         default:
 462                 /* shouldn't ever happen */
 463                 seq_puts(s, "unknown");
 464                 break;
 465         }
 466
 467         if (ses->sign)
 468                 seq_puts(s, "i");
 469
 470         if (ses->sectype == Kerberos)
 471                 seq_printf(s, ",cruid=%u",
 472                            from_kuid_munged(&init_user_ns, ses->cred_uid));
 473 }
 474
 475 static void
 476 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 477 {
 478         seq_puts(s, ",cache=");
 479
 480         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 481                 seq_puts(s, "strict");
 482         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 483                 seq_puts(s, "none");
 484         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
 485                 seq_puts(s, "singleclient"); /* assume only one client access */
 486         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
 487                 seq_puts(s, "ro"); /* read only caching assumed */
 488         else
 489                 seq_puts(s, "loose");
 490 }
 491
 492 /*
 493  * cifs_show_devname() is used so we show the mount device name with correct
 494  * format (e.g. forward slashes vs. back slashes) in /proc/mounts
 495  */
 496 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
 497 {
 498         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 499         char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
 500
 501         if (devname == NULL)
 502                 seq_puts(m, "none");
 503         else {
 504                 convert_delimiter(devname, '/');
 505                 /* escape all spaces in share names */
 506                 seq_escape(m, devname, " \t");
 507                 kfree(devname);
 508         }
 509         return 0;
 510 }
 511
 512 /*
 513  * cifs_show_options() is for displaying mount options in /proc/mounts.
 514  * Not all settable options are displayed but most of the important
 515  * ones are.
 516  */
 517 static int
 518 cifs_show_options(struct seq_file *s, struct dentry *root)
 519 {
 520         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 521         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 522         struct sockaddr *srcaddr;
 523         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 524
 525         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 526         cifs_show_security(s, tcon->ses);
 527         cifs_show_cache_flavor(s, cifs_sb);
 528
 529         if (tcon->no_lease)
 530                 seq_puts(s, ",nolease");
 531         if (cifs_sb->ctx->multiuser)
 532                 seq_puts(s, ",multiuser");
 533         else if (tcon->ses->user_name)
 534                 seq_show_option(s, "username", tcon->ses->user_name);
 535
 536         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 537                 seq_show_option(s, "domain", tcon->ses->domainName);
 538
 539         if (srcaddr->sa_family != AF_UNSPEC) {
 540                 struct sockaddr_in *saddr4;
 541                 struct sockaddr_in6 *saddr6;
 542                 saddr4 = (struct sockaddr_in *)srcaddr;
 543                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 544                 if (srcaddr->sa_family == AF_INET6)
 545                         seq_printf(s, ",srcaddr=%pI6c",
 546                                    &saddr6->sin6_addr);
 547                 else if (srcaddr->sa_family == AF_INET)
 548                         seq_printf(s, ",srcaddr=%pI4",
 549                                    &saddr4->sin_addr.s_addr);
 550                 else
 551                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 552                                    (int)(srcaddr->sa_family));
 553         }
 554
 555         seq_printf(s, ",uid=%u",
 556                    from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
 557         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 558                 seq_puts(s, ",forceuid");
 559         else
 560                 seq_puts(s, ",noforceuid");
 561
 562         seq_printf(s, ",gid=%u",
 563                    from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
 564         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 565                 seq_puts(s, ",forcegid");
 566         else
 567                 seq_puts(s, ",noforcegid");
 568
 569         cifs_show_address(s, tcon->ses->server);
 570
 571         if (!tcon->unix_ext)
 572                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 573                                            cifs_sb->ctx->file_mode,
 574                                            cifs_sb->ctx->dir_mode);
 575         if (cifs_sb->ctx->iocharset)
 576                 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
 577         if (tcon->seal)
 578                 seq_puts(s, ",seal");
 579         else if (tcon->ses->server->ignore_signature)
 580                 seq_puts(s, ",signloosely");
 581         if (tcon->nocase)
 582                 seq_puts(s, ",nocase");
 583         if (tcon->nodelete)
 584                 seq_puts(s, ",nodelete");
 585         if (tcon->local_lease)
 586                 seq_puts(s, ",locallease");
 587         if (tcon->retry)
 588                 seq_puts(s, ",hard");
 589         else
 590                 seq_puts(s, ",soft");
 591         if (tcon->use_persistent)
 592                 seq_puts(s, ",persistenthandles");
 593         else if (tcon->use_resilient)
 594                 seq_puts(s, ",resilienthandles");
 595         if (tcon->posix_extensions)
 596                 seq_puts(s, ",posix");
 597         else if (tcon->unix_ext)
 598                 seq_puts(s, ",unix");
 599         else
 600                 seq_puts(s, ",nounix");
 601         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
 602                 seq_puts(s, ",nodfs");
 603         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 604                 seq_puts(s, ",posixpaths");
 605         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 606                 seq_puts(s, ",setuids");
 607         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 608                 seq_puts(s, ",idsfromsid");
 609         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 610                 seq_puts(s, ",serverino");
 611         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 612                 seq_puts(s, ",rwpidforward");
 613         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 614                 seq_puts(s, ",forcemand");
 615         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 616                 seq_puts(s, ",nouser_xattr");
 617         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 618                 seq_puts(s, ",mapchars");
 619         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 620                 seq_puts(s, ",mapposix");
 621         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 622                 seq_puts(s, ",sfu");
 623         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 624                 seq_puts(s, ",nobrl");
 625         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
 626                 seq_puts(s, ",nohandlecache");
 627         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
 628                 seq_puts(s, ",modefromsid");
 629         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 630                 seq_puts(s, ",cifsacl");
 631         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 632                 seq_puts(s, ",dynperm");
 633         if (root->d_sb->s_flags & SB_POSIXACL)
 634                 seq_puts(s, ",acl");
 635         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 636                 seq_puts(s, ",mfsymlinks");
 637         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 638                 seq_puts(s, ",fsc");
 639         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 640                 seq_puts(s, ",nostrictsync");
 641         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 642                 seq_puts(s, ",noperm");
 643         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 644                 seq_printf(s, ",backupuid=%u",
 645                            from_kuid_munged(&init_user_ns,
 646                                             cifs_sb->ctx->backupuid));
 647         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 648                 seq_printf(s, ",backupgid=%u",
 649                            from_kgid_munged(&init_user_ns,
 650                                             cifs_sb->ctx->backupgid));
 651
 652         seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
 653         seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
 654         seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
 655         if (cifs_sb->ctx->rasize)
 656                 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
 657         if (tcon->ses->server->min_offload)
 658                 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
 659         seq_printf(s, ",echo_interval=%lu",
 660                         tcon->ses->server->echo_interval / HZ);
 661
 662         /* Only display max_credits if it was overridden on mount */
 663         if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
 664                 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
 665
 666         if (tcon->snapshot_time)
 667                 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
 668         if (tcon->handle_timeout)
 669                 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
 670
 671         /*
 672          * Display file and directory attribute timeout in seconds.
 673          * If file and directory attribute timeout the same then actimeo
 674          * was likely specified on mount
 675          */
 676         if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
 677                 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
 678         else {
 679                 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
 680                 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
 681         }
 682
 683         if (tcon->ses->chan_max > 1)
 684                 seq_printf(s, ",multichannel,max_channels=%zu",
 685                            tcon->ses->chan_max);
 686
 687         if (tcon->use_witness)
 688                 seq_puts(s, ",witness");
 689
 690         return 0;
 691 }
 692
 693 static void cifs_umount_begin(struct super_block *sb)
 694 {
 695         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 696         struct cifs_tcon *tcon;
 697
 698         if (cifs_sb == NULL)
 699                 return;
 700
 701         tcon = cifs_sb_master_tcon(cifs_sb);
 702
 703         spin_lock(&cifs_tcp_ses_lock);
 704         if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {
 705                 /* we have other mounts to same share or we have
 706                    already tried to force umount this and woken up
 707                    all waiting network requests, nothing to do */
 708                 spin_unlock(&cifs_tcp_ses_lock);
 709                 return;
 710         } else if (tcon->tc_count == 1)
 711                 tcon->status = TID_EXITING;
 712         spin_unlock(&cifs_tcp_ses_lock);
 713
 714         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 715         /* cancel_notify_requests(tcon); */
 716         if (tcon->ses && tcon->ses->server) {
 717                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 718                 wake_up_all(&tcon->ses->server->request_q);
 719                 wake_up_all(&tcon->ses->server->response_q);
 720                 msleep(1); /* yield */
 721                 /* we have to kick the requests once more */
 722                 wake_up_all(&tcon->ses->server->response_q);
 723                 msleep(1);
 724         }
 725
 726         return;
 727 }
 728
 729 #ifdef CONFIG_CIFS_STATS2
 730 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 731 {
 732         /* BB FIXME */
 733         return 0;
 734 }
 735 #endif
 736
 737 static int cifs_write_inode(struct inode *inode, struct writeback_control *wbc)
 738 {
 739         fscache_unpin_writeback(wbc, cifs_inode_cookie(inode));
 740         return 0;
 741 }
 742
 743 static int cifs_drop_inode(struct inode *inode)
 744 {
 745         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 746
 747         /* no serverino => unconditional eviction */
 748         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 749                 generic_drop_inode(inode);
 750 }
 751
 752 static const struct super_operations cifs_super_ops = {
 753         .statfs = cifs_statfs,
 754         .alloc_inode = cifs_alloc_inode,
 755         .write_inode    = cifs_write_inode,
 756         .free_inode = cifs_free_inode,
 757         .drop_inode     = cifs_drop_inode,
 758         .evict_inode    = cifs_evict_inode,
 759 /*      .show_path      = cifs_show_path, */ /* Would we ever need show path? */
 760         .show_devname   = cifs_show_devname,
 761 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 762         function unless later we add lazy close of inodes or unless the
 763         kernel forgets to call us with the same number of releases (closes)
 764         as opens */
 765         .show_options = cifs_show_options,
 766         .umount_begin   = cifs_umount_begin,
 767 #ifdef CONFIG_CIFS_STATS2
 768         .show_stats = cifs_show_stats,
 769 #endif
 770 };
 771
 772 /*
 773  * Get root dentry from superblock according to prefix path mount option.
 774  * Return dentry with refcount + 1 on success and NULL otherwise.
 775  */
 776 static struct dentry *
 777 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
 778 {
 779         struct dentry *dentry;
 780         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 781         char *full_path = NULL;
 782         char *s, *p;
 783         char sep;
 784
 785         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 786                 return dget(sb->s_root);
 787
 788         full_path = cifs_build_path_to_root(ctx, cifs_sb,
 789                                 cifs_sb_master_tcon(cifs_sb), 0);
 790         if (full_path == NULL)
 791                 return ERR_PTR(-ENOMEM);
 792
 793         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 794
 795         sep = CIFS_DIR_SEP(cifs_sb);
 796         dentry = dget(sb->s_root);
 797         s = full_path;
 798
 799         do {
 800                 struct inode *dir = d_inode(dentry);
 801                 struct dentry *child;
 802
 803                 if (!S_ISDIR(dir->i_mode)) {
 804                         dput(dentry);
 805                         dentry = ERR_PTR(-ENOTDIR);
 806                         break;
 807                 }
 808
 809                 /* skip separators */
 810                 while (*s == sep)
 811                         s++;
 812                 if (!*s)
 813                         break;
 814                 p = s++;
 815                 /* next separator */
 816                 while (*s && *s != sep)
 817                         s++;
 818
 819                 child = lookup_positive_unlocked(p, dentry, s - p);
 820                 dput(dentry);
 821                 dentry = child;
 822         } while (!IS_ERR(dentry));
 823         kfree(full_path);
 824         return dentry;
 825 }
 826
 827 static int cifs_set_super(struct super_block *sb, void *data)
 828 {
 829         struct cifs_mnt_data *mnt_data = data;
 830         sb->s_fs_info = mnt_data->cifs_sb;
 831         return set_anon_super(sb, NULL);
 832 }
 833
 834 struct dentry *
 835 cifs_smb3_do_mount(struct file_system_type *fs_type,
 836               int flags, struct smb3_fs_context *old_ctx)
 837 {
 838         int rc;
 839         struct super_block *sb;
 840         struct cifs_sb_info *cifs_sb = NULL;
 841         struct cifs_mnt_data mnt_data;
 842         struct dentry *root;
 843
 844         /*
 845          * Prints in Kernel / CIFS log the attempted mount operation
 846          *      If CIFS_DEBUG && cifs_FYI
 847          */
 848         if (cifsFYI)
 849                 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
 850         else
 851                 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
 852
 853         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 854         if (cifs_sb == NULL) {
 855                 root = ERR_PTR(-ENOMEM);
 856                 goto out;
 857         }
 858
 859         cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
 860         if (!cifs_sb->ctx) {
 861                 root = ERR_PTR(-ENOMEM);
 862                 goto out;
 863         }
 864         rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
 865         if (rc) {
 866                 root = ERR_PTR(rc);
 867                 goto out;
 868         }
 869
 870         rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
 871         if (rc) {
 872                 root = ERR_PTR(rc);
 873                 goto out;
 874         }
 875
 876         rc = cifs_setup_cifs_sb(cifs_sb);
 877         if (rc) {
 878                 root = ERR_PTR(rc);
 879                 goto out;
 880         }
 881
 882         rc = cifs_mount(cifs_sb, cifs_sb->ctx);
 883         if (rc) {
 884                 if (!(flags & SB_SILENT))
 885                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 886                                  rc);
 887                 root = ERR_PTR(rc);
 888                 goto out;
 889         }
 890
 891         mnt_data.ctx = cifs_sb->ctx;
 892         mnt_data.cifs_sb = cifs_sb;
 893         mnt_data.flags = flags;
 894
 895         /* BB should we make this contingent on mount parm? */
 896         flags |= SB_NODIRATIME | SB_NOATIME;
 897
 898         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 899         if (IS_ERR(sb)) {
 900                 root = ERR_CAST(sb);
 901                 cifs_umount(cifs_sb);
 902                 cifs_sb = NULL;
 903                 goto out;
 904         }
 905
 906         if (sb->s_root) {
 907                 cifs_dbg(FYI, "Use existing superblock\n");
 908                 cifs_umount(cifs_sb);
 909                 cifs_sb = NULL;
 910         } else {
 911                 rc = cifs_read_super(sb);
 912                 if (rc) {
 913                         root = ERR_PTR(rc);
 914                         goto out_super;
 915                 }
 916
 917                 sb->s_flags |= SB_ACTIVE;
 918         }
 919
 920         root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
 921         if (IS_ERR(root))
 922                 goto out_super;
 923
 924         if (cifs_sb)
 925                 cifs_sb->root = dget(root);
 926
 927         cifs_dbg(FYI, "dentry root is: %p\n", root);
 928         return root;
 929
 930 out_super:
 931         deactivate_locked_super(sb);
 932         return root;
 933 out:
 934         if (cifs_sb) {
 935                 kfree(cifs_sb->prepath);
 936                 smb3_cleanup_fs_context(cifs_sb->ctx);
 937                 kfree(cifs_sb);
 938         }
 939         return root;
 940 }
 941
 942
 943 static ssize_t
 944 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 945 {
 946         ssize_t rc;
 947         struct inode *inode = file_inode(iocb->ki_filp);
 948
 949         if (iocb->ki_flags & IOCB_DIRECT)
 950                 return cifs_user_readv(iocb, iter);
 951
 952         rc = cifs_revalidate_mapping(inode);
 953         if (rc)
 954                 return rc;
 955
 956         return generic_file_read_iter(iocb, iter);
 957 }
 958
 959 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 960 {
 961         struct inode *inode = file_inode(iocb->ki_filp);
 962         struct cifsInodeInfo *cinode = CIFS_I(inode);
 963         ssize_t written;
 964         int rc;
 965
 966         if (iocb->ki_filp->f_flags & O_DIRECT) {
 967                 written = cifs_user_writev(iocb, from);
 968                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 969                         cifs_zap_mapping(inode);
 970                         cifs_dbg(FYI,
 971                                  "Set no oplock for inode=%p after a write operation\n",
 972                                  inode);
 973                         cinode->oplock = 0;
 974                 }
 975                 return written;
 976         }
 977
 978         written = cifs_get_writer(cinode);
 979         if (written)
 980                 return written;
 981
 982         written = generic_file_write_iter(iocb, from);
 983
 984         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 985                 goto out;
 986
 987         rc = filemap_fdatawrite(inode->i_mapping);
 988         if (rc)
 989                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 990                          rc, inode);
 991
 992 out:
 993         cifs_put_writer(cinode);
 994         return written;
 995 }
 996
 997 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 998 {
 999         struct cifsFileInfo *cfile = file->private_data;
1000         struct cifs_tcon *tcon;
1001
1002         /*
1003          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1004          * the cached file length
1005          */
1006         if (whence != SEEK_SET && whence != SEEK_CUR) {
1007                 int rc;
1008                 struct inode *inode = file_inode(file);
1009
1010                 /*
1011                  * We need to be sure that all dirty pages are written and the
1012                  * server has the newest file length.
1013                  */
1014                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1015                     inode->i_mapping->nrpages != 0) {
1016                         rc = filemap_fdatawait(inode->i_mapping);
1017                         if (rc) {
1018                                 mapping_set_error(inode->i_mapping, rc);
1019                                 return rc;
1020                         }
1021                 }
1022                 /*
1023                  * Some applications poll for the file length in this strange
1024                  * way so we must seek to end on non-oplocked files by
1025                  * setting the revalidate time to zero.
1026                  */
1027                 CIFS_I(inode)->time = 0;
1028
1029                 rc = cifs_revalidate_file_attr(file);
1030                 if (rc < 0)
1031                         return (loff_t)rc;
1032         }
1033         if (cfile && cfile->tlink) {
1034                 tcon = tlink_tcon(cfile->tlink);
1035                 if (tcon->ses->server->ops->llseek)
1036                         return tcon->ses->server->ops->llseek(file, tcon,
1037                                                               offset, whence);
1038         }
1039         return generic_file_llseek(file, offset, whence);
1040 }
1041
1042 static int
1043 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1044 {
1045         /*
1046          * Note that this is called by vfs setlease with i_lock held to
1047          * protect *lease from going away.
1048          */
1049         struct inode *inode = file_inode(file);
1050         struct cifsFileInfo *cfile = file->private_data;
1051
1052         if (!(S_ISREG(inode->i_mode)))
1053                 return -EINVAL;
1054
1055         /* Check if file is oplocked if this is request for new lease */
1056         if (arg == F_UNLCK ||
1057             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1058             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1059                 return generic_setlease(file, arg, lease, priv);
1060         else if (tlink_tcon(cfile->tlink)->local_lease &&
1061                  !CIFS_CACHE_READ(CIFS_I(inode)))
1062                 /*
1063                  * If the server claims to support oplock on this file, then we
1064                  * still need to check oplock even if the local_lease mount
1065                  * option is set, but there are servers which do not support
1066                  * oplock for which this mount option may be useful if the user
1067                  * knows that the file won't be changed on the server by anyone
1068                  * else.
1069                  */
1070                 return generic_setlease(file, arg, lease, priv);
1071         else
1072                 return -EAGAIN;
1073 }
1074
1075 struct file_system_type cifs_fs_type = {
1076         .owner = THIS_MODULE,
1077         .name = "cifs",
1078         .init_fs_context = smb3_init_fs_context,
1079         .parameters = smb3_fs_parameters,
1080         .kill_sb = cifs_kill_sb,
1081         .fs_flags = FS_RENAME_DOES_D_MOVE,
1082 };
1083 MODULE_ALIAS_FS("cifs");
1084
1085 static struct file_system_type smb3_fs_type = {
1086         .owner = THIS_MODULE,
1087         .name = "smb3",
1088         .init_fs_context = smb3_init_fs_context,
1089         .parameters = smb3_fs_parameters,
1090         .kill_sb = cifs_kill_sb,
1091         .fs_flags = FS_RENAME_DOES_D_MOVE,
1092 };
1093 MODULE_ALIAS_FS("smb3");
1094 MODULE_ALIAS("smb3");
1095
1096 const struct inode_operations cifs_dir_inode_ops = {
1097         .create = cifs_create,
1098         .atomic_open = cifs_atomic_open,
1099         .lookup = cifs_lookup,
1100         .getattr = cifs_getattr,
1101         .unlink = cifs_unlink,
1102         .link = cifs_hardlink,
1103         .mkdir = cifs_mkdir,
1104         .rmdir = cifs_rmdir,
1105         .rename = cifs_rename2,
1106         .permission = cifs_permission,
1107         .setattr = cifs_setattr,
1108         .symlink = cifs_symlink,
1109         .mknod   = cifs_mknod,
1110         .listxattr = cifs_listxattr,
1111 };
1112
1113 const struct inode_operations cifs_file_inode_ops = {
1114         .setattr = cifs_setattr,
1115         .getattr = cifs_getattr,
1116         .permission = cifs_permission,
1117         .listxattr = cifs_listxattr,
1118         .fiemap = cifs_fiemap,
1119 };
1120
1121 const struct inode_operations cifs_symlink_inode_ops = {
1122         .get_link = cifs_get_link,
1123         .permission = cifs_permission,
1124         .listxattr = cifs_listxattr,
1125 };
1126
1127 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1128                 struct file *dst_file, loff_t destoff, loff_t len,
1129                 unsigned int remap_flags)
1130 {
1131         struct inode *src_inode = file_inode(src_file);
1132         struct inode *target_inode = file_inode(dst_file);
1133         struct cifsFileInfo *smb_file_src = src_file->private_data;
1134         struct cifsFileInfo *smb_file_target;
1135         struct cifs_tcon *target_tcon;
1136         unsigned int xid;
1137         int rc;
1138
1139         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1140                 return -EINVAL;
1141
1142         cifs_dbg(FYI, "clone range\n");
1143
1144         xid = get_xid();
1145
1146         if (!src_file->private_data || !dst_file->private_data) {
1147                 rc = -EBADF;
1148                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1149                 goto out;
1150         }
1151
1152         smb_file_target = dst_file->private_data;
1153         target_tcon = tlink_tcon(smb_file_target->tlink);
1154
1155         /*
1156          * Note: cifs case is easier than btrfs since server responsible for
1157          * checks for proper open modes and file type and if it wants
1158          * server could even support copy of range where source = target
1159          */
1160         lock_two_nondirectories(target_inode, src_inode);
1161
1162         if (len == 0)
1163                 len = src_inode->i_size - off;
1164
1165         cifs_dbg(FYI, "about to flush pages\n");
1166         /* should we flush first and last page first */
1167         truncate_inode_pages_range(&target_inode->i_data, destoff,
1168                                    PAGE_ALIGN(destoff + len)-1);
1169
1170         if (target_tcon->ses->server->ops->duplicate_extents)
1171                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1172                         smb_file_src, smb_file_target, off, len, destoff);
1173         else
1174                 rc = -EOPNOTSUPP;
1175
1176         /* force revalidate of size and timestamps of target file now
1177            that target is updated on the server */
1178         CIFS_I(target_inode)->time = 0;
1179         /* although unlocking in the reverse order from locking is not
1180            strictly necessary here it is a little cleaner to be consistent */
1181         unlock_two_nondirectories(src_inode, target_inode);
1182 out:
1183         free_xid(xid);
1184         return rc < 0 ? rc : len;
1185 }
1186
1187 ssize_t cifs_file_copychunk_range(unsigned int xid,
1188                                 struct file *src_file, loff_t off,
1189                                 struct file *dst_file, loff_t destoff,
1190                                 size_t len, unsigned int flags)
1191 {
1192         struct inode *src_inode = file_inode(src_file);
1193         struct inode *target_inode = file_inode(dst_file);
1194         struct cifsFileInfo *smb_file_src;
1195         struct cifsFileInfo *smb_file_target;
1196         struct cifs_tcon *src_tcon;
1197         struct cifs_tcon *target_tcon;
1198         ssize_t rc;
1199
1200         cifs_dbg(FYI, "copychunk range\n");
1201
1202         if (!src_file->private_data || !dst_file->private_data) {
1203                 rc = -EBADF;
1204                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1205                 goto out;
1206         }
1207
1208         rc = -EXDEV;
1209         smb_file_target = dst_file->private_data;
1210         smb_file_src = src_file->private_data;
1211         src_tcon = tlink_tcon(smb_file_src->tlink);
1212         target_tcon = tlink_tcon(smb_file_target->tlink);
1213
1214         if (src_tcon->ses != target_tcon->ses) {
1215                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1216                 goto out;
1217         }
1218
1219         rc = -EOPNOTSUPP;
1220         if (!target_tcon->ses->server->ops->copychunk_range)
1221                 goto out;
1222
1223         /*
1224          * Note: cifs case is easier than btrfs since server responsible for
1225          * checks for proper open modes and file type and if it wants
1226          * server could even support copy of range where source = target
1227          */
1228         lock_two_nondirectories(target_inode, src_inode);
1229
1230         cifs_dbg(FYI, "about to flush pages\n");
1231         /* should we flush first and last page first */
1232         truncate_inode_pages(&target_inode->i_data, 0);
1233
1234         rc = file_modified(dst_file);
1235         if (!rc)
1236                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1237                         smb_file_src, smb_file_target, off, len, destoff);
1238
1239         file_accessed(src_file);
1240
1241         /* force revalidate of size and timestamps of target file now
1242          * that target is updated on the server
1243          */
1244         CIFS_I(target_inode)->time = 0;
1245         /* although unlocking in the reverse order from locking is not
1246          * strictly necessary here it is a little cleaner to be consistent
1247          */
1248         unlock_two_nondirectories(src_inode, target_inode);
1249
1250 out:
1251         return rc;
1252 }
1253
1254 /*
1255  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1256  * is a dummy operation.
1257  */
1258 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1259 {
1260         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1261                  file, datasync);
1262
1263         return 0;
1264 }
1265
1266 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1267                                 struct file *dst_file, loff_t destoff,
1268                                 size_t len, unsigned int flags)
1269 {
1270         unsigned int xid = get_xid();
1271         ssize_t rc;
1272         struct cifsFileInfo *cfile = dst_file->private_data;
1273
1274         if (cfile->swapfile)
1275                 return -EOPNOTSUPP;
1276
1277         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1278                                         len, flags);
1279         free_xid(xid);
1280
1281         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1282                 rc = generic_copy_file_range(src_file, off, dst_file,
1283                                              destoff, len, flags);
1284         return rc;
1285 }
1286
1287 const struct file_operations cifs_file_ops = {
1288         .read_iter = cifs_loose_read_iter,
1289         .write_iter = cifs_file_write_iter,
1290         .open = cifs_open,
1291         .release = cifs_close,
1292         .lock = cifs_lock,
1293         .flock = cifs_flock,
1294         .fsync = cifs_fsync,
1295         .flush = cifs_flush,
1296         .mmap  = cifs_file_mmap,
1297         .splice_read = generic_file_splice_read,
1298         .splice_write = iter_file_splice_write,
1299         .llseek = cifs_llseek,
1300         .unlocked_ioctl = cifs_ioctl,
1301         .copy_file_range = cifs_copy_file_range,
1302         .remap_file_range = cifs_remap_file_range,
1303         .setlease = cifs_setlease,
1304         .fallocate = cifs_fallocate,
1305 };
1306
1307 const struct file_operations cifs_file_strict_ops = {
1308         .read_iter = cifs_strict_readv,
1309         .write_iter = cifs_strict_writev,
1310         .open = cifs_open,
1311         .release = cifs_close,
1312         .lock = cifs_lock,
1313         .flock = cifs_flock,
1314         .fsync = cifs_strict_fsync,
1315         .flush = cifs_flush,
1316         .mmap = cifs_file_strict_mmap,
1317         .splice_read = generic_file_splice_read,
1318         .splice_write = iter_file_splice_write,
1319         .llseek = cifs_llseek,
1320         .unlocked_ioctl = cifs_ioctl,
1321         .copy_file_range = cifs_copy_file_range,
1322         .remap_file_range = cifs_remap_file_range,
1323         .setlease = cifs_setlease,
1324         .fallocate = cifs_fallocate,
1325 };
1326
1327 const struct file_operations cifs_file_direct_ops = {
1328         .read_iter = cifs_direct_readv,
1329         .write_iter = cifs_direct_writev,
1330         .open = cifs_open,
1331         .release = cifs_close,
1332         .lock = cifs_lock,
1333         .flock = cifs_flock,
1334         .fsync = cifs_fsync,
1335         .flush = cifs_flush,
1336         .mmap = cifs_file_mmap,
1337         .splice_read = generic_file_splice_read,
1338         .splice_write = iter_file_splice_write,
1339         .unlocked_ioctl  = cifs_ioctl,
1340         .copy_file_range = cifs_copy_file_range,
1341         .remap_file_range = cifs_remap_file_range,
1342         .llseek = cifs_llseek,
1343         .setlease = cifs_setlease,
1344         .fallocate = cifs_fallocate,
1345 };
1346
1347 const struct file_operations cifs_file_nobrl_ops = {
1348         .read_iter = cifs_loose_read_iter,
1349         .write_iter = cifs_file_write_iter,
1350         .open = cifs_open,
1351         .release = cifs_close,
1352         .fsync = cifs_fsync,
1353         .flush = cifs_flush,
1354         .mmap  = cifs_file_mmap,
1355         .splice_read = generic_file_splice_read,
1356         .splice_write = iter_file_splice_write,
1357         .llseek = cifs_llseek,
1358         .unlocked_ioctl = cifs_ioctl,
1359         .copy_file_range = cifs_copy_file_range,
1360         .remap_file_range = cifs_remap_file_range,
1361         .setlease = cifs_setlease,
1362         .fallocate = cifs_fallocate,
1363 };
1364
1365 const struct file_operations cifs_file_strict_nobrl_ops = {
1366         .read_iter = cifs_strict_readv,
1367         .write_iter = cifs_strict_writev,
1368         .open = cifs_open,
1369         .release = cifs_close,
1370         .fsync = cifs_strict_fsync,
1371         .flush = cifs_flush,
1372         .mmap = cifs_file_strict_mmap,
1373         .splice_read = generic_file_splice_read,
1374         .splice_write = iter_file_splice_write,
1375         .llseek = cifs_llseek,
1376         .unlocked_ioctl = cifs_ioctl,
1377         .copy_file_range = cifs_copy_file_range,
1378         .remap_file_range = cifs_remap_file_range,
1379         .setlease = cifs_setlease,
1380         .fallocate = cifs_fallocate,
1381 };
1382
1383 const struct file_operations cifs_file_direct_nobrl_ops = {
1384         .read_iter = cifs_direct_readv,
1385         .write_iter = cifs_direct_writev,
1386         .open = cifs_open,
1387         .release = cifs_close,
1388         .fsync = cifs_fsync,
1389         .flush = cifs_flush,
1390         .mmap = cifs_file_mmap,
1391         .splice_read = generic_file_splice_read,
1392         .splice_write = iter_file_splice_write,
1393         .unlocked_ioctl  = cifs_ioctl,
1394         .copy_file_range = cifs_copy_file_range,
1395         .remap_file_range = cifs_remap_file_range,
1396         .llseek = cifs_llseek,
1397         .setlease = cifs_setlease,
1398         .fallocate = cifs_fallocate,
1399 };
1400
1401 const struct file_operations cifs_dir_ops = {
1402         .iterate_shared = cifs_readdir,
1403         .release = cifs_closedir,
1404         .read    = generic_read_dir,
1405         .unlocked_ioctl  = cifs_ioctl,
1406         .copy_file_range = cifs_copy_file_range,
1407         .remap_file_range = cifs_remap_file_range,
1408         .llseek = generic_file_llseek,
1409         .fsync = cifs_dir_fsync,
1410 };
1411
1412 static void
1413 cifs_init_once(void *inode)
1414 {
1415         struct cifsInodeInfo *cifsi = inode;
1416
1417         inode_init_once(&cifsi->vfs_inode);
1418         init_rwsem(&cifsi->lock_sem);
1419 }
1420
1421 static int __init
1422 cifs_init_inodecache(void)
1423 {
1424         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1425                                               sizeof(struct cifsInodeInfo),
1426                                               0, (SLAB_RECLAIM_ACCOUNT|
1427                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1428                                               cifs_init_once);
1429         if (cifs_inode_cachep == NULL)
1430                 return -ENOMEM;
1431
1432         return 0;
1433 }
1434
1435 static void
1436 cifs_destroy_inodecache(void)
1437 {
1438         /*
1439          * Make sure all delayed rcu free inodes are flushed before we
1440          * destroy cache.
1441          */
1442         rcu_barrier();
1443         kmem_cache_destroy(cifs_inode_cachep);
1444 }
1445
1446 static int
1447 cifs_init_request_bufs(void)
1448 {
1449         /*
1450          * SMB2 maximum header size is bigger than CIFS one - no problems to
1451          * allocate some more bytes for CIFS.
1452          */
1453         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1454
1455         if (CIFSMaxBufSize < 8192) {
1456         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1457         Unicode path name has to fit in any SMB/CIFS path based frames */
1458                 CIFSMaxBufSize = 8192;
1459         } else if (CIFSMaxBufSize > 1024*127) {
1460                 CIFSMaxBufSize = 1024 * 127;
1461         } else {
1462                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1463         }
1464 /*
1465         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1466                  CIFSMaxBufSize, CIFSMaxBufSize);
1467 */
1468         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1469                                             CIFSMaxBufSize + max_hdr_size, 0,
1470                                             SLAB_HWCACHE_ALIGN, 0,
1471                                             CIFSMaxBufSize + max_hdr_size,
1472                                             NULL);
1473         if (cifs_req_cachep == NULL)
1474                 return -ENOMEM;
1475
1476         if (cifs_min_rcv < 1)
1477                 cifs_min_rcv = 1;
1478         else if (cifs_min_rcv > 64) {
1479                 cifs_min_rcv = 64;
1480                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1481         }
1482
1483         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1484                                                   cifs_req_cachep);
1485
1486         if (cifs_req_poolp == NULL) {
1487                 kmem_cache_destroy(cifs_req_cachep);
1488                 return -ENOMEM;
1489         }
1490         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1491         almost all handle based requests (but not write response, nor is it
1492         sufficient for path based requests).  A smaller size would have
1493         been more efficient (compacting multiple slab items on one 4k page)
1494         for the case in which debug was on, but this larger size allows
1495         more SMBs to use small buffer alloc and is still much more
1496         efficient to alloc 1 per page off the slab compared to 17K (5page)
1497         alloc of large cifs buffers even when page debugging is on */
1498         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1499                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1500                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1501         if (cifs_sm_req_cachep == NULL) {
1502                 mempool_destroy(cifs_req_poolp);
1503                 kmem_cache_destroy(cifs_req_cachep);
1504                 return -ENOMEM;
1505         }
1506
1507         if (cifs_min_small < 2)
1508                 cifs_min_small = 2;
1509         else if (cifs_min_small > 256) {
1510                 cifs_min_small = 256;
1511                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1512         }
1513
1514         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1515                                                      cifs_sm_req_cachep);
1516
1517         if (cifs_sm_req_poolp == NULL) {
1518                 mempool_destroy(cifs_req_poolp);
1519                 kmem_cache_destroy(cifs_req_cachep);
1520                 kmem_cache_destroy(cifs_sm_req_cachep);
1521                 return -ENOMEM;
1522         }
1523
1524         return 0;
1525 }
1526
1527 static void
1528 cifs_destroy_request_bufs(void)
1529 {
1530         mempool_destroy(cifs_req_poolp);
1531         kmem_cache_destroy(cifs_req_cachep);
1532         mempool_destroy(cifs_sm_req_poolp);
1533         kmem_cache_destroy(cifs_sm_req_cachep);
1534 }
1535
1536 static int
1537 cifs_init_mids(void)
1538 {
1539         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1540                                             sizeof(struct mid_q_entry), 0,
1541                                             SLAB_HWCACHE_ALIGN, NULL);
1542         if (cifs_mid_cachep == NULL)
1543                 return -ENOMEM;
1544
1545         /* 3 is a reasonable minimum number of simultaneous operations */
1546         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1547         if (cifs_mid_poolp == NULL) {
1548                 kmem_cache_destroy(cifs_mid_cachep);
1549                 return -ENOMEM;
1550         }
1551
1552         return 0;
1553 }
1554
1555 static void
1556 cifs_destroy_mids(void)
1557 {
1558         mempool_destroy(cifs_mid_poolp);
1559         kmem_cache_destroy(cifs_mid_cachep);
1560 }
1561
1562 static int __init
1563 init_cifs(void)
1564 {
1565         int rc = 0;
1566         cifs_proc_init();
1567         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1568 /*
1569  *  Initialize Global counters
1570  */
1571         atomic_set(&sesInfoAllocCount, 0);
1572         atomic_set(&tconInfoAllocCount, 0);
1573         atomic_set(&tcpSesNextId, 0);
1574         atomic_set(&tcpSesAllocCount, 0);
1575         atomic_set(&tcpSesReconnectCount, 0);
1576         atomic_set(&tconInfoReconnectCount, 0);
1577
1578         atomic_set(&bufAllocCount, 0);
1579         atomic_set(&smBufAllocCount, 0);
1580 #ifdef CONFIG_CIFS_STATS2
1581         atomic_set(&totBufAllocCount, 0);
1582         atomic_set(&totSmBufAllocCount, 0);
1583         if (slow_rsp_threshold < 1)
1584                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1585         else if (slow_rsp_threshold > 32767)
1586                 cifs_dbg(VFS,
1587                        "slow response threshold set higher than recommended (0 to 32767)\n");
1588 #endif /* CONFIG_CIFS_STATS2 */
1589
1590         atomic_set(&midCount, 0);
1591         GlobalCurrentXid = 0;
1592         GlobalTotalActiveXid = 0;
1593         GlobalMaxActiveXid = 0;
1594         spin_lock_init(&cifs_tcp_ses_lock);
1595         spin_lock_init(&GlobalMid_Lock);
1596
1597         cifs_lock_secret = get_random_u32();
1598
1599         if (cifs_max_pending < 2) {
1600                 cifs_max_pending = 2;
1601                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1602         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1603                 cifs_max_pending = CIFS_MAX_REQ;
1604                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1605                          CIFS_MAX_REQ);
1606         }
1607
1608         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1609         if (!cifsiod_wq) {
1610                 rc = -ENOMEM;
1611                 goto out_clean_proc;
1612         }
1613
1614         /*
1615          * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1616          * so that we don't launch too many worker threads but
1617          * Documentation/core-api/workqueue.rst recommends setting it to 0
1618          */
1619
1620         /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1621         decrypt_wq = alloc_workqueue("smb3decryptd",
1622                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1623         if (!decrypt_wq) {
1624                 rc = -ENOMEM;
1625                 goto out_destroy_cifsiod_wq;
1626         }
1627
1628         fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1629                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1630         if (!fileinfo_put_wq) {
1631                 rc = -ENOMEM;
1632                 goto out_destroy_decrypt_wq;
1633         }
1634
1635         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1636                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1637         if (!cifsoplockd_wq) {
1638                 rc = -ENOMEM;
1639                 goto out_destroy_fileinfo_put_wq;
1640         }
1641
1642         deferredclose_wq = alloc_workqueue("deferredclose",
1643                                            WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1644         if (!deferredclose_wq) {
1645                 rc = -ENOMEM;
1646                 goto out_destroy_cifsoplockd_wq;
1647         }
1648
1649         rc = cifs_init_inodecache();
1650         if (rc)
1651                 goto out_destroy_deferredclose_wq;
1652
1653         rc = cifs_init_mids();
1654         if (rc)
1655                 goto out_destroy_inodecache;
1656
1657         rc = cifs_init_request_bufs();
1658         if (rc)
1659                 goto out_destroy_mids;
1660
1661 #ifdef CONFIG_CIFS_DFS_UPCALL
1662         rc = dfs_cache_init();
1663         if (rc)
1664                 goto out_destroy_request_bufs;
1665 #endif /* CONFIG_CIFS_DFS_UPCALL */
1666 #ifdef CONFIG_CIFS_UPCALL
1667         rc = init_cifs_spnego();
1668         if (rc)
1669                 goto out_destroy_dfs_cache;
1670 #endif /* CONFIG_CIFS_UPCALL */
1671 #ifdef CONFIG_CIFS_SWN_UPCALL
1672         rc = cifs_genl_init();
1673         if (rc)
1674                 goto out_register_key_type;
1675 #endif /* CONFIG_CIFS_SWN_UPCALL */
1676
1677         rc = init_cifs_idmap();
1678         if (rc)
1679                 goto out_cifs_swn_init;
1680
1681         rc = register_filesystem(&cifs_fs_type);
1682         if (rc)
1683                 goto out_init_cifs_idmap;
1684
1685         rc = register_filesystem(&smb3_fs_type);
1686         if (rc) {
1687                 unregister_filesystem(&cifs_fs_type);
1688                 goto out_init_cifs_idmap;
1689         }
1690
1691         return 0;
1692
1693 out_init_cifs_idmap:
1694         exit_cifs_idmap();
1695 out_cifs_swn_init:
1696 #ifdef CONFIG_CIFS_SWN_UPCALL
1697         cifs_genl_exit();
1698 out_register_key_type:
1699 #endif
1700 #ifdef CONFIG_CIFS_UPCALL
1701         exit_cifs_spnego();
1702 out_destroy_dfs_cache:
1703 #endif
1704 #ifdef CONFIG_CIFS_DFS_UPCALL
1705         dfs_cache_destroy();
1706 out_destroy_request_bufs:
1707 #endif
1708         cifs_destroy_request_bufs();
1709 out_destroy_mids:
1710         cifs_destroy_mids();
1711 out_destroy_inodecache:
1712         cifs_destroy_inodecache();
1713 out_destroy_deferredclose_wq:
1714         destroy_workqueue(deferredclose_wq);
1715 out_destroy_cifsoplockd_wq:
1716         destroy_workqueue(cifsoplockd_wq);
1717 out_destroy_fileinfo_put_wq:
1718         destroy_workqueue(fileinfo_put_wq);
1719 out_destroy_decrypt_wq:
1720         destroy_workqueue(decrypt_wq);
1721 out_destroy_cifsiod_wq:
1722         destroy_workqueue(cifsiod_wq);
1723 out_clean_proc:
1724         cifs_proc_clean();
1725         return rc;
1726 }
1727
1728 static void __exit
1729 exit_cifs(void)
1730 {
1731         cifs_dbg(NOISY, "exit_smb3\n");
1732         unregister_filesystem(&cifs_fs_type);
1733         unregister_filesystem(&smb3_fs_type);
1734         cifs_dfs_release_automount_timer();
1735         exit_cifs_idmap();
1736 #ifdef CONFIG_CIFS_SWN_UPCALL
1737         cifs_genl_exit();
1738 #endif
1739 #ifdef CONFIG_CIFS_UPCALL
1740         exit_cifs_spnego();
1741 #endif
1742 #ifdef CONFIG_CIFS_DFS_UPCALL
1743         dfs_cache_destroy();
1744 #endif
1745         cifs_destroy_request_bufs();
1746         cifs_destroy_mids();
1747         cifs_destroy_inodecache();
1748         destroy_workqueue(deferredclose_wq);
1749         destroy_workqueue(cifsoplockd_wq);
1750         destroy_workqueue(decrypt_wq);
1751         destroy_workqueue(fileinfo_put_wq);
1752         destroy_workqueue(cifsiod_wq);
1753         cifs_proc_clean();
1754 }
1755
1756 MODULE_AUTHOR("Steve French");
1757 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1758 MODULE_DESCRIPTION
1759         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1760         "also older servers complying with the SNIA CIFS Specification)");
1761 MODULE_VERSION(CIFS_VERSION);
1762 MODULE_SOFTDEP("ecb");
1763 MODULE_SOFTDEP("hmac");
1764 MODULE_SOFTDEP("md5");
1765 MODULE_SOFTDEP("nls");
1766 MODULE_SOFTDEP("aes");
1767 MODULE_SOFTDEP("cmac");
1768 MODULE_SOFTDEP("sha256");
1769 MODULE_SOFTDEP("sha512");
1770 MODULE_SOFTDEP("aead2");
1771 MODULE_SOFTDEP("ccm");
1772 MODULE_SOFTDEP("gcm");
1773 module_init(init_cifs)
1774 module_exit(exit_cifs)