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->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 381         cifs_inode->server_eof = 0;
 382         cifs_inode->uniqueid = 0;
 383         cifs_inode->createtime = 0;
 384         cifs_inode->epoch = 0;
 385         spin_lock_init(&cifs_inode->open_file_lock);
 386         generate_random_uuid(cifs_inode->lease_key);
 387
 388         /*
 389          * Can not set i_flags here - they get immediately overwritten to zero
 390          * by the VFS.
 391          */
 392         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 393         INIT_LIST_HEAD(&cifs_inode->openFileList);
 394         INIT_LIST_HEAD(&cifs_inode->llist);
 395         INIT_LIST_HEAD(&cifs_inode->deferred_closes);
 396         spin_lock_init(&cifs_inode->deferred_lock);
 397         return &cifs_inode->vfs_inode;
 398 }
 399
 400 static void
 401 cifs_free_inode(struct inode *inode)
 402 {
 403         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 404 }
 405
 406 static void
 407 cifs_evict_inode(struct inode *inode)
 408 {
 409         truncate_inode_pages_final(&inode->i_data);
 410         if (inode->i_state & I_PINNING_FSCACHE_WB)
 411                 cifs_fscache_unuse_inode_cookie(inode, true);
 412         cifs_fscache_release_inode_cookie(inode);
 413         clear_inode(inode);
 414 }
 415
 416 static void
 417 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 418 {
 419         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 420         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 421
 422         seq_puts(s, ",addr=");
 423
 424         switch (server->dstaddr.ss_family) {
 425         case AF_INET:
 426                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 427                 break;
 428         case AF_INET6:
 429                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 430                 if (sa6->sin6_scope_id)
 431                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 432                 break;
 433         default:
 434                 seq_puts(s, "(unknown)");
 435         }
 436         if (server->rdma)
 437                 seq_puts(s, ",rdma");
 438 }
 439
 440 static void
 441 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 442 {
 443         if (ses->sectype == Unspecified) {
 444                 if (ses->user_name == NULL)
 445                         seq_puts(s, ",sec=none");
 446                 return;
 447         }
 448
 449         seq_puts(s, ",sec=");
 450
 451         switch (ses->sectype) {
 452         case NTLMv2:
 453                 seq_puts(s, "ntlmv2");
 454                 break;
 455         case Kerberos:
 456                 seq_puts(s, "krb5");
 457                 break;
 458         case RawNTLMSSP:
 459                 seq_puts(s, "ntlmssp");
 460                 break;
 461         default:
 462                 /* shouldn't ever happen */
 463                 seq_puts(s, "unknown");
 464                 break;
 465         }
 466
 467         if (ses->sign)
 468                 seq_puts(s, "i");
 469
 470         if (ses->sectype == Kerberos)
 471                 seq_printf(s, ",cruid=%u",
 472                            from_kuid_munged(&init_user_ns, ses->cred_uid));
 473 }
 474
 475 static void
 476 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 477 {
 478         seq_puts(s, ",cache=");
 479
 480         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 481                 seq_puts(s, "strict");
 482         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 483                 seq_puts(s, "none");
 484         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
 485                 seq_puts(s, "singleclient"); /* assume only one client access */
 486         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
 487                 seq_puts(s, "ro"); /* read only caching assumed */
 488         else
 489                 seq_puts(s, "loose");
 490 }
 491
 492 /*
 493  * cifs_show_devname() is used so we show the mount device name with correct
 494  * format (e.g. forward slashes vs. back slashes) in /proc/mounts
 495  */
 496 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
 497 {
 498         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 499         char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
 500
 501         if (devname == NULL)
 502                 seq_puts(m, "none");
 503         else {
 504                 convert_delimiter(devname, '/');
 505                 /* escape all spaces in share names */
 506                 seq_escape(m, devname, " \t");
 507                 kfree(devname);
 508         }
 509         return 0;
 510 }
 511
 512 /*
 513  * cifs_show_options() is for displaying mount options in /proc/mounts.
 514  * Not all settable options are displayed but most of the important
 515  * ones are.
 516  */
 517 static int
 518 cifs_show_options(struct seq_file *s, struct dentry *root)
 519 {
 520         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 521         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 522         struct sockaddr *srcaddr;
 523         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 524
 525         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 526         cifs_show_security(s, tcon->ses);
 527         cifs_show_cache_flavor(s, cifs_sb);
 528
 529         if (tcon->no_lease)
 530                 seq_puts(s, ",nolease");
 531         if (cifs_sb->ctx->multiuser)
 532                 seq_puts(s, ",multiuser");
 533         else if (tcon->ses->user_name)
 534                 seq_show_option(s, "username", tcon->ses->user_name);
 535
 536         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 537                 seq_show_option(s, "domain", tcon->ses->domainName);
 538
 539         if (srcaddr->sa_family != AF_UNSPEC) {
 540                 struct sockaddr_in *saddr4;
 541                 struct sockaddr_in6 *saddr6;
 542                 saddr4 = (struct sockaddr_in *)srcaddr;
 543                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 544                 if (srcaddr->sa_family == AF_INET6)
 545                         seq_printf(s, ",srcaddr=%pI6c",
 546                                    &saddr6->sin6_addr);
 547                 else if (srcaddr->sa_family == AF_INET)
 548                         seq_printf(s, ",srcaddr=%pI4",
 549                                    &saddr4->sin_addr.s_addr);
 550                 else
 551                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 552                                    (int)(srcaddr->sa_family));
 553         }
 554
 555         seq_printf(s, ",uid=%u",
 556                    from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
 557         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 558                 seq_puts(s, ",forceuid");
 559         else
 560                 seq_puts(s, ",noforceuid");
 561
 562         seq_printf(s, ",gid=%u",
 563                    from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
 564         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 565                 seq_puts(s, ",forcegid");
 566         else
 567                 seq_puts(s, ",noforcegid");
 568
 569         cifs_show_address(s, tcon->ses->server);
 570
 571         if (!tcon->unix_ext)
 572                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 573                                            cifs_sb->ctx->file_mode,
 574                                            cifs_sb->ctx->dir_mode);
 575         if (cifs_sb->ctx->iocharset)
 576                 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
 577         if (tcon->seal)
 578                 seq_puts(s, ",seal");
 579         else if (tcon->ses->server->ignore_signature)
 580                 seq_puts(s, ",signloosely");
 581         if (tcon->nocase)
 582                 seq_puts(s, ",nocase");
 583         if (tcon->nodelete)
 584                 seq_puts(s, ",nodelete");
 585         if (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;
 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                 kfree(cifs_sb->prepath);
 938                 smb3_cleanup_fs_context(cifs_sb->ctx);
 939                 kfree(cifs_sb);
 940         }
 941         return root;
 942 }
 943
 944
 945 static ssize_t
 946 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 947 {
 948         ssize_t rc;
 949         struct inode *inode = file_inode(iocb->ki_filp);
 950
 951         if (iocb->ki_flags & IOCB_DIRECT)
 952                 return cifs_user_readv(iocb, iter);
 953
 954         rc = cifs_revalidate_mapping(inode);
 955         if (rc)
 956                 return rc;
 957
 958         return generic_file_read_iter(iocb, iter);
 959 }
 960
 961 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 962 {
 963         struct inode *inode = file_inode(iocb->ki_filp);
 964         struct cifsInodeInfo *cinode = CIFS_I(inode);
 965         ssize_t written;
 966         int rc;
 967
 968         if (iocb->ki_filp->f_flags & O_DIRECT) {
 969                 written = cifs_user_writev(iocb, from);
 970                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 971                         cifs_zap_mapping(inode);
 972                         cifs_dbg(FYI,
 973                                  "Set no oplock for inode=%p after a write operation\n",
 974                                  inode);
 975                         cinode->oplock = 0;
 976                 }
 977                 return written;
 978         }
 979
 980         written = cifs_get_writer(cinode);
 981         if (written)
 982                 return written;
 983
 984         written = generic_file_write_iter(iocb, from);
 985
 986         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 987                 goto out;
 988
 989         rc = filemap_fdatawrite(inode->i_mapping);
 990         if (rc)
 991                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 992                          rc, inode);
 993
 994 out:
 995         cifs_put_writer(cinode);
 996         return written;
 997 }
 998
 999 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1000 {
1001         struct cifsFileInfo *cfile = file->private_data;
1002         struct cifs_tcon *tcon;
1003
1004         /*
1005          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1006          * the cached file length
1007          */
1008         if (whence != SEEK_SET && whence != SEEK_CUR) {
1009                 int rc;
1010                 struct inode *inode = file_inode(file);
1011
1012                 /*
1013                  * We need to be sure that all dirty pages are written and the
1014                  * server has the newest file length.
1015                  */
1016                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1017                     inode->i_mapping->nrpages != 0) {
1018                         rc = filemap_fdatawait(inode->i_mapping);
1019                         if (rc) {
1020                                 mapping_set_error(inode->i_mapping, rc);
1021                                 return rc;
1022                         }
1023                 }
1024                 /*
1025                  * Some applications poll for the file length in this strange
1026                  * way so we must seek to end on non-oplocked files by
1027                  * setting the revalidate time to zero.
1028                  */
1029                 CIFS_I(inode)->time = 0;
1030
1031                 rc = cifs_revalidate_file_attr(file);
1032                 if (rc < 0)
1033                         return (loff_t)rc;
1034         }
1035         if (cfile && cfile->tlink) {
1036                 tcon = tlink_tcon(cfile->tlink);
1037                 if (tcon->ses->server->ops->llseek)
1038                         return tcon->ses->server->ops->llseek(file, tcon,
1039                                                               offset, whence);
1040         }
1041         return generic_file_llseek(file, offset, whence);
1042 }
1043
1044 static int
1045 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1046 {
1047         /*
1048          * Note that this is called by vfs setlease with i_lock held to
1049          * protect *lease from going away.
1050          */
1051         struct inode *inode = file_inode(file);
1052         struct cifsFileInfo *cfile = file->private_data;
1053
1054         if (!(S_ISREG(inode->i_mode)))
1055                 return -EINVAL;
1056
1057         /* Check if file is oplocked if this is request for new lease */
1058         if (arg == F_UNLCK ||
1059             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1060             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1061                 return generic_setlease(file, arg, lease, priv);
1062         else if (tlink_tcon(cfile->tlink)->local_lease &&
1063                  !CIFS_CACHE_READ(CIFS_I(inode)))
1064                 /*
1065                  * If the server claims to support oplock on this file, then we
1066                  * still need to check oplock even if the local_lease mount
1067                  * option is set, but there are servers which do not support
1068                  * oplock for which this mount option may be useful if the user
1069                  * knows that the file won't be changed on the server by anyone
1070                  * else.
1071                  */
1072                 return generic_setlease(file, arg, lease, priv);
1073         else
1074                 return -EAGAIN;
1075 }
1076
1077 struct file_system_type cifs_fs_type = {
1078         .owner = THIS_MODULE,
1079         .name = "cifs",
1080         .init_fs_context = smb3_init_fs_context,
1081         .parameters = smb3_fs_parameters,
1082         .kill_sb = cifs_kill_sb,
1083         .fs_flags = FS_RENAME_DOES_D_MOVE,
1084 };
1085 MODULE_ALIAS_FS("cifs");
1086
1087 static struct file_system_type smb3_fs_type = {
1088         .owner = THIS_MODULE,
1089         .name = "smb3",
1090         .init_fs_context = smb3_init_fs_context,
1091         .parameters = smb3_fs_parameters,
1092         .kill_sb = cifs_kill_sb,
1093         .fs_flags = FS_RENAME_DOES_D_MOVE,
1094 };
1095 MODULE_ALIAS_FS("smb3");
1096 MODULE_ALIAS("smb3");
1097
1098 const struct inode_operations cifs_dir_inode_ops = {
1099         .create = cifs_create,
1100         .atomic_open = cifs_atomic_open,
1101         .lookup = cifs_lookup,
1102         .getattr = cifs_getattr,
1103         .unlink = cifs_unlink,
1104         .link = cifs_hardlink,
1105         .mkdir = cifs_mkdir,
1106         .rmdir = cifs_rmdir,
1107         .rename = cifs_rename2,
1108         .permission = cifs_permission,
1109         .setattr = cifs_setattr,
1110         .symlink = cifs_symlink,
1111         .mknod   = cifs_mknod,
1112         .listxattr = cifs_listxattr,
1113 };
1114
1115 const struct inode_operations cifs_file_inode_ops = {
1116         .setattr = cifs_setattr,
1117         .getattr = cifs_getattr,
1118         .permission = cifs_permission,
1119         .listxattr = cifs_listxattr,
1120         .fiemap = cifs_fiemap,
1121 };
1122
1123 const struct inode_operations cifs_symlink_inode_ops = {
1124         .get_link = cifs_get_link,
1125         .permission = cifs_permission,
1126         .listxattr = cifs_listxattr,
1127 };
1128
1129 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1130                 struct file *dst_file, loff_t destoff, loff_t len,
1131                 unsigned int remap_flags)
1132 {
1133         struct inode *src_inode = file_inode(src_file);
1134         struct inode *target_inode = file_inode(dst_file);
1135         struct cifsFileInfo *smb_file_src = src_file->private_data;
1136         struct cifsFileInfo *smb_file_target;
1137         struct cifs_tcon *target_tcon;
1138         unsigned int xid;
1139         int rc;
1140
1141         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1142                 return -EINVAL;
1143
1144         cifs_dbg(FYI, "clone range\n");
1145
1146         xid = get_xid();
1147
1148         if (!src_file->private_data || !dst_file->private_data) {
1149                 rc = -EBADF;
1150                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1151                 goto out;
1152         }
1153
1154         smb_file_target = dst_file->private_data;
1155         target_tcon = tlink_tcon(smb_file_target->tlink);
1156
1157         /*
1158          * Note: cifs case is easier than btrfs since server responsible for
1159          * checks for proper open modes and file type and if it wants
1160          * server could even support copy of range where source = target
1161          */
1162         lock_two_nondirectories(target_inode, src_inode);
1163
1164         if (len == 0)
1165                 len = src_inode->i_size - off;
1166
1167         cifs_dbg(FYI, "about to flush pages\n");
1168         /* should we flush first and last page first */
1169         truncate_inode_pages_range(&target_inode->i_data, destoff,
1170                                    PAGE_ALIGN(destoff + len)-1);
1171
1172         if (target_tcon->ses->server->ops->duplicate_extents)
1173                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1174                         smb_file_src, smb_file_target, off, len, destoff);
1175         else
1176                 rc = -EOPNOTSUPP;
1177
1178         /* force revalidate of size and timestamps of target file now
1179            that target is updated on the server */
1180         CIFS_I(target_inode)->time = 0;
1181         /* although unlocking in the reverse order from locking is not
1182            strictly necessary here it is a little cleaner to be consistent */
1183         unlock_two_nondirectories(src_inode, target_inode);
1184 out:
1185         free_xid(xid);
1186         return rc < 0 ? rc : len;
1187 }
1188
1189 ssize_t cifs_file_copychunk_range(unsigned int xid,
1190                                 struct file *src_file, loff_t off,
1191                                 struct file *dst_file, loff_t destoff,
1192                                 size_t len, unsigned int flags)
1193 {
1194         struct inode *src_inode = file_inode(src_file);
1195         struct inode *target_inode = file_inode(dst_file);
1196         struct cifsFileInfo *smb_file_src;
1197         struct cifsFileInfo *smb_file_target;
1198         struct cifs_tcon *src_tcon;
1199         struct cifs_tcon *target_tcon;
1200         ssize_t rc;
1201
1202         cifs_dbg(FYI, "copychunk range\n");
1203
1204         if (!src_file->private_data || !dst_file->private_data) {
1205                 rc = -EBADF;
1206                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1207                 goto out;
1208         }
1209
1210         rc = -EXDEV;
1211         smb_file_target = dst_file->private_data;
1212         smb_file_src = src_file->private_data;
1213         src_tcon = tlink_tcon(smb_file_src->tlink);
1214         target_tcon = tlink_tcon(smb_file_target->tlink);
1215
1216         if (src_tcon->ses != target_tcon->ses) {
1217                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1218                 goto out;
1219         }
1220
1221         rc = -EOPNOTSUPP;
1222         if (!target_tcon->ses->server->ops->copychunk_range)
1223                 goto out;
1224
1225         /*
1226          * Note: cifs case is easier than btrfs since server responsible for
1227          * checks for proper open modes and file type and if it wants
1228          * server could even support copy of range where source = target
1229          */
1230         lock_two_nondirectories(target_inode, src_inode);
1231
1232         cifs_dbg(FYI, "about to flush pages\n");
1233         /* should we flush first and last page first */
1234         truncate_inode_pages(&target_inode->i_data, 0);
1235
1236         rc = file_modified(dst_file);
1237         if (!rc)
1238                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1239                         smb_file_src, smb_file_target, off, len, destoff);
1240
1241         file_accessed(src_file);
1242
1243         /* force revalidate of size and timestamps of target file now
1244          * that target is updated on the server
1245          */
1246         CIFS_I(target_inode)->time = 0;
1247         /* although unlocking in the reverse order from locking is not
1248          * strictly necessary here it is a little cleaner to be consistent
1249          */
1250         unlock_two_nondirectories(src_inode, target_inode);
1251
1252 out:
1253         return rc;
1254 }
1255
1256 /*
1257  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1258  * is a dummy operation.
1259  */
1260 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1261 {
1262         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1263                  file, datasync);
1264
1265         return 0;
1266 }
1267
1268 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1269                                 struct file *dst_file, loff_t destoff,
1270                                 size_t len, unsigned int flags)
1271 {
1272         unsigned int xid = get_xid();
1273         ssize_t rc;
1274         struct cifsFileInfo *cfile = dst_file->private_data;
1275
1276         if (cfile->swapfile)
1277                 return -EOPNOTSUPP;
1278
1279         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1280                                         len, flags);
1281         free_xid(xid);
1282
1283         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1284                 rc = generic_copy_file_range(src_file, off, dst_file,
1285                                              destoff, len, flags);
1286         return rc;
1287 }
1288
1289 const struct file_operations cifs_file_ops = {
1290         .read_iter = cifs_loose_read_iter,
1291         .write_iter = cifs_file_write_iter,
1292         .open = cifs_open,
1293         .release = cifs_close,
1294         .lock = cifs_lock,
1295         .flock = cifs_flock,
1296         .fsync = cifs_fsync,
1297         .flush = cifs_flush,
1298         .mmap  = cifs_file_mmap,
1299         .splice_read = generic_file_splice_read,
1300         .splice_write = iter_file_splice_write,
1301         .llseek = cifs_llseek,
1302         .unlocked_ioctl = cifs_ioctl,
1303         .copy_file_range = cifs_copy_file_range,
1304         .remap_file_range = cifs_remap_file_range,
1305         .setlease = cifs_setlease,
1306         .fallocate = cifs_fallocate,
1307 };
1308
1309 const struct file_operations cifs_file_strict_ops = {
1310         .read_iter = cifs_strict_readv,
1311         .write_iter = cifs_strict_writev,
1312         .open = cifs_open,
1313         .release = cifs_close,
1314         .lock = cifs_lock,
1315         .flock = cifs_flock,
1316         .fsync = cifs_strict_fsync,
1317         .flush = cifs_flush,
1318         .mmap = cifs_file_strict_mmap,
1319         .splice_read = generic_file_splice_read,
1320         .splice_write = iter_file_splice_write,
1321         .llseek = cifs_llseek,
1322         .unlocked_ioctl = cifs_ioctl,
1323         .copy_file_range = cifs_copy_file_range,
1324         .remap_file_range = cifs_remap_file_range,
1325         .setlease = cifs_setlease,
1326         .fallocate = cifs_fallocate,
1327 };
1328
1329 const struct file_operations cifs_file_direct_ops = {
1330         .read_iter = cifs_direct_readv,
1331         .write_iter = cifs_direct_writev,
1332         .open = cifs_open,
1333         .release = cifs_close,
1334         .lock = cifs_lock,
1335         .flock = cifs_flock,
1336         .fsync = cifs_fsync,
1337         .flush = cifs_flush,
1338         .mmap = cifs_file_mmap,
1339         .splice_read = generic_file_splice_read,
1340         .splice_write = iter_file_splice_write,
1341         .unlocked_ioctl  = cifs_ioctl,
1342         .copy_file_range = cifs_copy_file_range,
1343         .remap_file_range = cifs_remap_file_range,
1344         .llseek = cifs_llseek,
1345         .setlease = cifs_setlease,
1346         .fallocate = cifs_fallocate,
1347 };
1348
1349 const struct file_operations cifs_file_nobrl_ops = {
1350         .read_iter = cifs_loose_read_iter,
1351         .write_iter = cifs_file_write_iter,
1352         .open = cifs_open,
1353         .release = cifs_close,
1354         .fsync = cifs_fsync,
1355         .flush = cifs_flush,
1356         .mmap  = cifs_file_mmap,
1357         .splice_read = generic_file_splice_read,
1358         .splice_write = iter_file_splice_write,
1359         .llseek = cifs_llseek,
1360         .unlocked_ioctl = cifs_ioctl,
1361         .copy_file_range = cifs_copy_file_range,
1362         .remap_file_range = cifs_remap_file_range,
1363         .setlease = cifs_setlease,
1364         .fallocate = cifs_fallocate,
1365 };
1366
1367 const struct file_operations cifs_file_strict_nobrl_ops = {
1368         .read_iter = cifs_strict_readv,
1369         .write_iter = cifs_strict_writev,
1370         .open = cifs_open,
1371         .release = cifs_close,
1372         .fsync = cifs_strict_fsync,
1373         .flush = cifs_flush,
1374         .mmap = cifs_file_strict_mmap,
1375         .splice_read = generic_file_splice_read,
1376         .splice_write = iter_file_splice_write,
1377         .llseek = cifs_llseek,
1378         .unlocked_ioctl = cifs_ioctl,
1379         .copy_file_range = cifs_copy_file_range,
1380         .remap_file_range = cifs_remap_file_range,
1381         .setlease = cifs_setlease,
1382         .fallocate = cifs_fallocate,
1383 };
1384
1385 const struct file_operations cifs_file_direct_nobrl_ops = {
1386         .read_iter = cifs_direct_readv,
1387         .write_iter = cifs_direct_writev,
1388         .open = cifs_open,
1389         .release = cifs_close,
1390         .fsync = cifs_fsync,
1391         .flush = cifs_flush,
1392         .mmap = cifs_file_mmap,
1393         .splice_read = generic_file_splice_read,
1394         .splice_write = iter_file_splice_write,
1395         .unlocked_ioctl  = cifs_ioctl,
1396         .copy_file_range = cifs_copy_file_range,
1397         .remap_file_range = cifs_remap_file_range,
1398         .llseek = cifs_llseek,
1399         .setlease = cifs_setlease,
1400         .fallocate = cifs_fallocate,
1401 };
1402
1403 const struct file_operations cifs_dir_ops = {
1404         .iterate_shared = cifs_readdir,
1405         .release = cifs_closedir,
1406         .read    = generic_read_dir,
1407         .unlocked_ioctl  = cifs_ioctl,
1408         .copy_file_range = cifs_copy_file_range,
1409         .remap_file_range = cifs_remap_file_range,
1410         .llseek = generic_file_llseek,
1411         .fsync = cifs_dir_fsync,
1412 };
1413
1414 static void
1415 cifs_init_once(void *inode)
1416 {
1417         struct cifsInodeInfo *cifsi = inode;
1418
1419         inode_init_once(&cifsi->vfs_inode);
1420         init_rwsem(&cifsi->lock_sem);
1421 }
1422
1423 static int __init
1424 cifs_init_inodecache(void)
1425 {
1426         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1427                                               sizeof(struct cifsInodeInfo),
1428                                               0, (SLAB_RECLAIM_ACCOUNT|
1429                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1430                                               cifs_init_once);
1431         if (cifs_inode_cachep == NULL)
1432                 return -ENOMEM;
1433
1434         return 0;
1435 }
1436
1437 static void
1438 cifs_destroy_inodecache(void)
1439 {
1440         /*
1441          * Make sure all delayed rcu free inodes are flushed before we
1442          * destroy cache.
1443          */
1444         rcu_barrier();
1445         kmem_cache_destroy(cifs_inode_cachep);
1446 }
1447
1448 static int
1449 cifs_init_request_bufs(void)
1450 {
1451         /*
1452          * SMB2 maximum header size is bigger than CIFS one - no problems to
1453          * allocate some more bytes for CIFS.
1454          */
1455         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1456
1457         if (CIFSMaxBufSize < 8192) {
1458         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1459         Unicode path name has to fit in any SMB/CIFS path based frames */
1460                 CIFSMaxBufSize = 8192;
1461         } else if (CIFSMaxBufSize > 1024*127) {
1462                 CIFSMaxBufSize = 1024 * 127;
1463         } else {
1464                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1465         }
1466 /*
1467         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1468                  CIFSMaxBufSize, CIFSMaxBufSize);
1469 */
1470         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1471                                             CIFSMaxBufSize + max_hdr_size, 0,
1472                                             SLAB_HWCACHE_ALIGN, 0,
1473                                             CIFSMaxBufSize + max_hdr_size,
1474                                             NULL);
1475         if (cifs_req_cachep == NULL)
1476                 return -ENOMEM;
1477
1478         if (cifs_min_rcv < 1)
1479                 cifs_min_rcv = 1;
1480         else if (cifs_min_rcv > 64) {
1481                 cifs_min_rcv = 64;
1482                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1483         }
1484
1485         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1486                                                   cifs_req_cachep);
1487
1488         if (cifs_req_poolp == NULL) {
1489                 kmem_cache_destroy(cifs_req_cachep);
1490                 return -ENOMEM;
1491         }
1492         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1493         almost all handle based requests (but not write response, nor is it
1494         sufficient for path based requests).  A smaller size would have
1495         been more efficient (compacting multiple slab items on one 4k page)
1496         for the case in which debug was on, but this larger size allows
1497         more SMBs to use small buffer alloc and is still much more
1498         efficient to alloc 1 per page off the slab compared to 17K (5page)
1499         alloc of large cifs buffers even when page debugging is on */
1500         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1501                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1502                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1503         if (cifs_sm_req_cachep == NULL) {
1504                 mempool_destroy(cifs_req_poolp);
1505                 kmem_cache_destroy(cifs_req_cachep);
1506                 return -ENOMEM;
1507         }
1508
1509         if (cifs_min_small < 2)
1510                 cifs_min_small = 2;
1511         else if (cifs_min_small > 256) {
1512                 cifs_min_small = 256;
1513                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1514         }
1515
1516         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1517                                                      cifs_sm_req_cachep);
1518
1519         if (cifs_sm_req_poolp == NULL) {
1520                 mempool_destroy(cifs_req_poolp);
1521                 kmem_cache_destroy(cifs_req_cachep);
1522                 kmem_cache_destroy(cifs_sm_req_cachep);
1523                 return -ENOMEM;
1524         }
1525
1526         return 0;
1527 }
1528
1529 static void
1530 cifs_destroy_request_bufs(void)
1531 {
1532         mempool_destroy(cifs_req_poolp);
1533         kmem_cache_destroy(cifs_req_cachep);
1534         mempool_destroy(cifs_sm_req_poolp);
1535         kmem_cache_destroy(cifs_sm_req_cachep);
1536 }
1537
1538 static int
1539 cifs_init_mids(void)
1540 {
1541         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1542                                             sizeof(struct mid_q_entry), 0,
1543                                             SLAB_HWCACHE_ALIGN, NULL);
1544         if (cifs_mid_cachep == NULL)
1545                 return -ENOMEM;
1546
1547         /* 3 is a reasonable minimum number of simultaneous operations */
1548         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1549         if (cifs_mid_poolp == NULL) {
1550                 kmem_cache_destroy(cifs_mid_cachep);
1551                 return -ENOMEM;
1552         }
1553
1554         return 0;
1555 }
1556
1557 static void
1558 cifs_destroy_mids(void)
1559 {
1560         mempool_destroy(cifs_mid_poolp);
1561         kmem_cache_destroy(cifs_mid_cachep);
1562 }
1563
1564 static int __init
1565 init_cifs(void)
1566 {
1567         int rc = 0;
1568         cifs_proc_init();
1569         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1570 /*
1571  *  Initialize Global counters
1572  */
1573         atomic_set(&sesInfoAllocCount, 0);
1574         atomic_set(&tconInfoAllocCount, 0);
1575         atomic_set(&tcpSesNextId, 0);
1576         atomic_set(&tcpSesAllocCount, 0);
1577         atomic_set(&tcpSesReconnectCount, 0);
1578         atomic_set(&tconInfoReconnectCount, 0);
1579
1580         atomic_set(&bufAllocCount, 0);
1581         atomic_set(&smBufAllocCount, 0);
1582 #ifdef CONFIG_CIFS_STATS2
1583         atomic_set(&totBufAllocCount, 0);
1584         atomic_set(&totSmBufAllocCount, 0);
1585         if (slow_rsp_threshold < 1)
1586                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1587         else if (slow_rsp_threshold > 32767)
1588                 cifs_dbg(VFS,
1589                        "slow response threshold set higher than recommended (0 to 32767)\n");
1590 #endif /* CONFIG_CIFS_STATS2 */
1591
1592         atomic_set(&midCount, 0);
1593         GlobalCurrentXid = 0;
1594         GlobalTotalActiveXid = 0;
1595         GlobalMaxActiveXid = 0;
1596         spin_lock_init(&cifs_tcp_ses_lock);
1597         spin_lock_init(&GlobalMid_Lock);
1598
1599         cifs_lock_secret = get_random_u32();
1600
1601         if (cifs_max_pending < 2) {
1602                 cifs_max_pending = 2;
1603                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1604         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1605                 cifs_max_pending = CIFS_MAX_REQ;
1606                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1607                          CIFS_MAX_REQ);
1608         }
1609
1610         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1611         if (!cifsiod_wq) {
1612                 rc = -ENOMEM;
1613                 goto out_clean_proc;
1614         }
1615
1616         /*
1617          * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1618          * so that we don't launch too many worker threads but
1619          * Documentation/core-api/workqueue.rst recommends setting it to 0
1620          */
1621
1622         /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1623         decrypt_wq = alloc_workqueue("smb3decryptd",
1624                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1625         if (!decrypt_wq) {
1626                 rc = -ENOMEM;
1627                 goto out_destroy_cifsiod_wq;
1628         }
1629
1630         fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1631                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1632         if (!fileinfo_put_wq) {
1633                 rc = -ENOMEM;
1634                 goto out_destroy_decrypt_wq;
1635         }
1636
1637         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1638                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1639         if (!cifsoplockd_wq) {
1640                 rc = -ENOMEM;
1641                 goto out_destroy_fileinfo_put_wq;
1642         }
1643
1644         deferredclose_wq = alloc_workqueue("deferredclose",
1645                                            WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1646         if (!deferredclose_wq) {
1647                 rc = -ENOMEM;
1648                 goto out_destroy_cifsoplockd_wq;
1649         }
1650
1651         rc = cifs_init_inodecache();
1652         if (rc)
1653                 goto out_destroy_deferredclose_wq;
1654
1655         rc = cifs_init_mids();
1656         if (rc)
1657                 goto out_destroy_inodecache;
1658
1659         rc = cifs_init_request_bufs();
1660         if (rc)
1661                 goto out_destroy_mids;
1662
1663 #ifdef CONFIG_CIFS_DFS_UPCALL
1664         rc = dfs_cache_init();
1665         if (rc)
1666                 goto out_destroy_request_bufs;
1667 #endif /* CONFIG_CIFS_DFS_UPCALL */
1668 #ifdef CONFIG_CIFS_UPCALL
1669         rc = init_cifs_spnego();
1670         if (rc)
1671                 goto out_destroy_dfs_cache;
1672 #endif /* CONFIG_CIFS_UPCALL */
1673 #ifdef CONFIG_CIFS_SWN_UPCALL
1674         rc = cifs_genl_init();
1675         if (rc)
1676                 goto out_register_key_type;
1677 #endif /* CONFIG_CIFS_SWN_UPCALL */
1678
1679         rc = init_cifs_idmap();
1680         if (rc)
1681                 goto out_cifs_swn_init;
1682
1683         rc = register_filesystem(&cifs_fs_type);
1684         if (rc)
1685                 goto out_init_cifs_idmap;
1686
1687         rc = register_filesystem(&smb3_fs_type);
1688         if (rc) {
1689                 unregister_filesystem(&cifs_fs_type);
1690                 goto out_init_cifs_idmap;
1691         }
1692
1693         return 0;
1694
1695 out_init_cifs_idmap:
1696         exit_cifs_idmap();
1697 out_cifs_swn_init:
1698 #ifdef CONFIG_CIFS_SWN_UPCALL
1699         cifs_genl_exit();
1700 out_register_key_type:
1701 #endif
1702 #ifdef CONFIG_CIFS_UPCALL
1703         exit_cifs_spnego();
1704 out_destroy_dfs_cache:
1705 #endif
1706 #ifdef CONFIG_CIFS_DFS_UPCALL
1707         dfs_cache_destroy();
1708 out_destroy_request_bufs:
1709 #endif
1710         cifs_destroy_request_bufs();
1711 out_destroy_mids:
1712         cifs_destroy_mids();
1713 out_destroy_inodecache:
1714         cifs_destroy_inodecache();
1715 out_destroy_deferredclose_wq:
1716         destroy_workqueue(deferredclose_wq);
1717 out_destroy_cifsoplockd_wq:
1718         destroy_workqueue(cifsoplockd_wq);
1719 out_destroy_fileinfo_put_wq:
1720         destroy_workqueue(fileinfo_put_wq);
1721 out_destroy_decrypt_wq:
1722         destroy_workqueue(decrypt_wq);
1723 out_destroy_cifsiod_wq:
1724         destroy_workqueue(cifsiod_wq);
1725 out_clean_proc:
1726         cifs_proc_clean();
1727         return rc;
1728 }
1729
1730 static void __exit
1731 exit_cifs(void)
1732 {
1733         cifs_dbg(NOISY, "exit_smb3\n");
1734         unregister_filesystem(&cifs_fs_type);
1735         unregister_filesystem(&smb3_fs_type);
1736         cifs_dfs_release_automount_timer();
1737         exit_cifs_idmap();
1738 #ifdef CONFIG_CIFS_SWN_UPCALL
1739         cifs_genl_exit();
1740 #endif
1741 #ifdef CONFIG_CIFS_UPCALL
1742         exit_cifs_spnego();
1743 #endif
1744 #ifdef CONFIG_CIFS_DFS_UPCALL
1745         dfs_cache_destroy();
1746 #endif
1747         cifs_destroy_request_bufs();
1748         cifs_destroy_mids();
1749         cifs_destroy_inodecache();
1750         destroy_workqueue(deferredclose_wq);
1751         destroy_workqueue(cifsoplockd_wq);
1752         destroy_workqueue(decrypt_wq);
1753         destroy_workqueue(fileinfo_put_wq);
1754         destroy_workqueue(cifsiod_wq);
1755         cifs_proc_clean();
1756 }
1757
1758 MODULE_AUTHOR("Steve French");
1759 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1760 MODULE_DESCRIPTION
1761         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1762         "also older servers complying with the SNIA CIFS Specification)");
1763 MODULE_VERSION(CIFS_VERSION);
1764 MODULE_SOFTDEP("ecb");
1765 MODULE_SOFTDEP("hmac");
1766 MODULE_SOFTDEP("md5");
1767 MODULE_SOFTDEP("nls");
1768 MODULE_SOFTDEP("aes");
1769 MODULE_SOFTDEP("cmac");
1770 MODULE_SOFTDEP("sha256");
1771 MODULE_SOFTDEP("sha512");
1772 MODULE_SOFTDEP("aead2");
1773 MODULE_SOFTDEP("ccm");
1774 MODULE_SOFTDEP("gcm");
1775 module_init(init_cifs)
1776 module_exit(exit_cifs)