fs/cifs/cifsfs.c

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