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