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