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