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 atomic_t mid_count;
  72 atomic_t buf_alloc_count;
  73 atomic_t small_buf_alloc_count;
  74 #ifdef CONFIG_CIFS_STATS2
  75 atomic_t total_buf_alloc_count;
  76 atomic_t total_small_buf_alloc_count;
  77 #endif/* STATS2 */
  78 static const struct super_operations cifs_super_ops;
  79 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  80 module_param(CIFSMaxBufSize, uint, 0444);
  81 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
  82                                  "for CIFS requests. "
  83                                  "Default: 16384 Range: 8192 to 130048");
  84 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  85 module_param(cifs_min_rcv, uint, 0444);
  86 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  87                                 "1 to 64");
  88 unsigned int cifs_min_small = 30;
  89 module_param(cifs_min_small, uint, 0444);
  90 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  91                                  "Range: 2 to 256");
  92 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  93 module_param(cifs_max_pending, uint, 0444);
  94 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
  95                                    "CIFS/SMB1 dialect (N/A for SMB3) "
  96                                    "Default: 32767 Range: 2 to 32767.");
  97 #ifdef CONFIG_CIFS_STATS2
  98 unsigned int slow_rsp_threshold = 1;
  99 module_param(slow_rsp_threshold, uint, 0644);
 100 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
 101                                    "before logging that a response is delayed. "
 102                                    "Default: 1 (if set to 0 disables msg).");
 103 #endif /* STATS2 */
 104
 105 module_param(enable_oplocks, bool, 0644);
 106 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
 107
 108 module_param(enable_gcm_256, bool, 0644);
 109 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
 110
 111 module_param(require_gcm_256, bool, 0644);
 112 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
 113
 114 module_param(enable_negotiate_signing, bool, 0644);
 115 MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
 116
 117 module_param(disable_legacy_dialects, bool, 0644);
 118 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
 119                                   "helpful to restrict the ability to "
 120                                   "override the default dialects (SMB2.1, "
 121                                   "SMB3 and SMB3.02) on mount with old "
 122                                   "dialects (CIFS/SMB1 and SMB2) since "
 123                                   "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
 124                                   " and less secure. Default: n/N/0");
 125
 126 extern mempool_t *cifs_sm_req_poolp;
 127 extern mempool_t *cifs_req_poolp;
 128 extern mempool_t *cifs_mid_poolp;
 129
 130 struct workqueue_struct *cifsiod_wq;
 131 struct workqueue_struct *decrypt_wq;
 132 struct workqueue_struct *fileinfo_put_wq;
 133 struct workqueue_struct *cifsoplockd_wq;
 134 struct workqueue_struct *deferredclose_wq;
 135 __u32 cifs_lock_secret;
 136
 137 /*
 138  * Bumps refcount for cifs super block.
 139  * Note that it should be only called if a referece to VFS super block is
 140  * already held, e.g. in open-type syscalls context. Otherwise it can race with
 141  * atomic_dec_and_test in deactivate_locked_super.
 142  */
 143 void
 144 cifs_sb_active(struct super_block *sb)
 145 {
 146         struct cifs_sb_info *server = CIFS_SB(sb);
 147
 148         if (atomic_inc_return(&server->active) == 1)
 149                 atomic_inc(&sb->s_active);
 150 }
 151
 152 void
 153 cifs_sb_deactive(struct super_block *sb)
 154 {
 155         struct cifs_sb_info *server = CIFS_SB(sb);
 156
 157         if (atomic_dec_and_test(&server->active))
 158                 deactivate_super(sb);
 159 }
 160
 161 static int
 162 cifs_read_super(struct super_block *sb)
 163 {
 164         struct inode *inode;
 165         struct cifs_sb_info *cifs_sb;
 166         struct cifs_tcon *tcon;
 167         struct timespec64 ts;
 168         int rc = 0;
 169
 170         cifs_sb = CIFS_SB(sb);
 171         tcon = cifs_sb_master_tcon(cifs_sb);
 172
 173         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 174                 sb->s_flags |= SB_POSIXACL;
 175
 176         if (tcon->snapshot_time)
 177                 sb->s_flags |= SB_RDONLY;
 178
 179         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 180                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 181         else
 182                 sb->s_maxbytes = MAX_NON_LFS;
 183
 184         /*
 185          * Some very old servers like DOS and OS/2 used 2 second granularity
 186          * (while all current servers use 100ns granularity - see MS-DTYP)
 187          * but 1 second is the maximum allowed granularity for the VFS
 188          * so for old servers set time granularity to 1 second while for
 189          * everything else (current servers) set it to 100ns.
 190          */
 191         if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
 192             ((tcon->ses->capabilities &
 193               tcon->ses->server->vals->cap_nt_find) == 0) &&
 194             !tcon->unix_ext) {
 195                 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
 196                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
 197                 sb->s_time_min = ts.tv_sec;
 198                 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
 199                                     cpu_to_le16(SMB_TIME_MAX), 0);
 200                 sb->s_time_max = ts.tv_sec;
 201         } else {
 202                 /*
 203                  * Almost every server, including all SMB2+, uses DCE TIME
 204                  * ie 100 nanosecond units, since 1601.  See MS-DTYP and MS-FSCC
 205                  */
 206                 sb->s_time_gran = 100;
 207                 ts = cifs_NTtimeToUnix(0);
 208                 sb->s_time_min = ts.tv_sec;
 209                 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
 210                 sb->s_time_max = ts.tv_sec;
 211         }
 212
 213         sb->s_magic = CIFS_SUPER_MAGIC;
 214         sb->s_op = &cifs_super_ops;
 215         sb->s_xattr = cifs_xattr_handlers;
 216         rc = super_setup_bdi(sb);
 217         if (rc)
 218                 goto out_no_root;
 219         /* tune readahead according to rsize if readahead size not set on mount */
 220         if (cifs_sb->ctx->rsize == 0)
 221                 cifs_sb->ctx->rsize =
 222                         tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);
 223         if (cifs_sb->ctx->rasize)
 224                 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
 225         else
 226                 sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
 227
 228         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 229         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 230         inode = cifs_root_iget(sb);
 231
 232         if (IS_ERR(inode)) {
 233                 rc = PTR_ERR(inode);
 234                 goto out_no_root;
 235         }
 236
 237         if (tcon->nocase)
 238                 sb->s_d_op = &cifs_ci_dentry_ops;
 239         else
 240                 sb->s_d_op = &cifs_dentry_ops;
 241
 242         sb->s_root = d_make_root(inode);
 243         if (!sb->s_root) {
 244                 rc = -ENOMEM;
 245                 goto out_no_root;
 246         }
 247
 248 #ifdef CONFIG_CIFS_NFSD_EXPORT
 249         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 250                 cifs_dbg(FYI, "export ops supported\n");
 251                 sb->s_export_op = &cifs_export_ops;
 252         }
 253 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 254
 255         return 0;
 256
 257 out_no_root:
 258         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 259         return rc;
 260 }
 261
 262 static void cifs_kill_sb(struct super_block *sb)
 263 {
 264         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 265         struct cifs_tcon *tcon;
 266         struct cached_fid *cfid;
 267         struct rb_root *root = &cifs_sb->tlink_tree;
 268         struct rb_node *node;
 269         struct tcon_link *tlink;
 270
 271         /*
 272          * We ned to release all dentries for the cached directories
 273          * before we kill the sb.
 274          */
 275         if (cifs_sb->root) {
 276                 for (node = rb_first(root); node; node = rb_next(node)) {
 277                         tlink = rb_entry(node, struct tcon_link, tl_rbnode);
 278                         tcon = tlink_tcon(tlink);
 279                         if (IS_ERR(tcon))
 280                                 continue;
 281                         cfid = &tcon->crfid;
 282                         mutex_lock(&cfid->fid_mutex);
 283                         if (cfid->dentry) {
 284                                 dput(cfid->dentry);
 285                                 cfid->dentry = NULL;
 286                         }
 287                         mutex_unlock(&cfid->fid_mutex);
 288                 }
 289
 290                 /* finally release root dentry */
 291                 dput(cifs_sb->root);
 292                 cifs_sb->root = NULL;
 293         }
 294
 295         kill_anon_super(sb);
 296         cifs_umount(cifs_sb);
 297 }
 298
 299 static int
 300 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 301 {
 302         struct super_block *sb = dentry->d_sb;
 303         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 304         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 305         struct TCP_Server_Info *server = tcon->ses->server;
 306         unsigned int xid;
 307         int rc = 0;
 308
 309         xid = get_xid();
 310
 311         if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
 312                 buf->f_namelen =
 313                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
 314         else
 315                 buf->f_namelen = PATH_MAX;
 316
 317         buf->f_fsid.val[0] = tcon->vol_serial_number;
 318         /* are using part of create time for more randomness, see man statfs */
 319         buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
 320
 321         buf->f_files = 0;       /* undefined */
 322         buf->f_ffree = 0;       /* unlimited */
 323
 324         if (server->ops->queryfs)
 325                 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
 326
 327         free_xid(xid);
 328         return rc;
 329 }
 330
 331 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 332 {
 333         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 334         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 335         struct TCP_Server_Info *server = tcon->ses->server;
 336
 337         if (server->ops->fallocate)
 338                 return server->ops->fallocate(file, tcon, mode, off, len);
 339
 340         return -EOPNOTSUPP;
 341 }
 342
 343 static int cifs_permission(struct user_namespace *mnt_userns,
 344                            struct inode *inode, int mask)
 345 {
 346         struct cifs_sb_info *cifs_sb;
 347
 348         cifs_sb = CIFS_SB(inode->i_sb);
 349
 350         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 351                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 352                         return -EACCES;
 353                 else
 354                         return 0;
 355         } else /* file mode might have been restricted at mount time
 356                 on the client (above and beyond ACL on servers) for
 357                 servers which do not support setting and viewing mode bits,
 358                 so allowing client to check permissions is useful */
 359                 return generic_permission(&init_user_ns, inode, mask);
 360 }
 361
 362 static struct kmem_cache *cifs_inode_cachep;
 363 static struct kmem_cache *cifs_req_cachep;
 364 static struct kmem_cache *cifs_mid_cachep;
 365 static struct kmem_cache *cifs_sm_req_cachep;
 366 mempool_t *cifs_sm_req_poolp;
 367 mempool_t *cifs_req_poolp;
 368 mempool_t *cifs_mid_poolp;
 369
 370 static struct inode *
 371 cifs_alloc_inode(struct super_block *sb)
 372 {
 373         struct cifsInodeInfo *cifs_inode;
 374         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 375         if (!cifs_inode)
 376                 return NULL;
 377         cifs_inode->cifsAttrs = 0x20;   /* default */
 378         cifs_inode->time = 0;
 379         /*
 380          * Until the file is open and we have gotten oplock info back from the
 381          * server, can not assume caching of file data or metadata.
 382          */
 383         cifs_set_oplock_level(cifs_inode, 0);
 384         cifs_inode->flags = 0;
 385         spin_lock_init(&cifs_inode->writers_lock);
 386         cifs_inode->writers = 0;
 387         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 388         cifs_inode->server_eof = 0;
 389         cifs_inode->uniqueid = 0;
 390         cifs_inode->createtime = 0;
 391         cifs_inode->epoch = 0;
 392         spin_lock_init(&cifs_inode->open_file_lock);
 393         generate_random_uuid(cifs_inode->lease_key);
 394
 395         /*
 396          * Can not set i_flags here - they get immediately overwritten to zero
 397          * by the VFS.
 398          */
 399         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 400         INIT_LIST_HEAD(&cifs_inode->openFileList);
 401         INIT_LIST_HEAD(&cifs_inode->llist);
 402         INIT_LIST_HEAD(&cifs_inode->deferred_closes);
 403         spin_lock_init(&cifs_inode->deferred_lock);
 404         return &cifs_inode->vfs_inode;
 405 }
 406
 407 static void
 408 cifs_free_inode(struct inode *inode)
 409 {
 410         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 411 }
 412
 413 static void
 414 cifs_evict_inode(struct inode *inode)
 415 {
 416         truncate_inode_pages_final(&inode->i_data);
 417         clear_inode(inode);
 418 }
 419
 420 static void
 421 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 422 {
 423         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 424         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 425
 426         seq_puts(s, ",addr=");
 427
 428         switch (server->dstaddr.ss_family) {
 429         case AF_INET:
 430                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 431                 break;
 432         case AF_INET6:
 433                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 434                 if (sa6->sin6_scope_id)
 435                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 436                 break;
 437         default:
 438                 seq_puts(s, "(unknown)");
 439         }
 440         if (server->rdma)
 441                 seq_puts(s, ",rdma");
 442 }
 443
 444 static void
 445 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 446 {
 447         if (ses->sectype == Unspecified) {
 448                 if (ses->user_name == NULL)
 449                         seq_puts(s, ",sec=none");
 450                 return;
 451         }
 452
 453         seq_puts(s, ",sec=");
 454
 455         switch (ses->sectype) {
 456         case NTLMv2:
 457                 seq_puts(s, "ntlmv2");
 458                 break;
 459         case Kerberos:
 460                 seq_puts(s, "krb5");
 461                 break;
 462         case RawNTLMSSP:
 463                 seq_puts(s, "ntlmssp");
 464                 break;
 465         default:
 466                 /* shouldn't ever happen */
 467                 seq_puts(s, "unknown");
 468                 break;
 469         }
 470
 471         if (ses->sign)
 472                 seq_puts(s, "i");
 473
 474         if (ses->sectype == Kerberos)
 475                 seq_printf(s, ",cruid=%u",
 476                            from_kuid_munged(&init_user_ns, ses->cred_uid));
 477 }
 478
 479 static void
 480 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 481 {
 482         seq_puts(s, ",cache=");
 483
 484         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 485                 seq_puts(s, "strict");
 486         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 487                 seq_puts(s, "none");
 488         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
 489                 seq_puts(s, "singleclient"); /* assume only one client access */
 490         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
 491                 seq_puts(s, "ro"); /* read only caching assumed */
 492         else
 493                 seq_puts(s, "loose");
 494 }
 495
 496 /*
 497  * cifs_show_devname() is used so we show the mount device name with correct
 498  * format (e.g. forward slashes vs. back slashes) in /proc/mounts
 499  */
 500 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
 501 {
 502         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 503         char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
 504
 505         if (devname == NULL)
 506                 seq_puts(m, "none");
 507         else {
 508                 convert_delimiter(devname, '/');
 509                 /* escape all spaces in share names */
 510                 seq_escape(m, devname, " \t");
 511                 kfree(devname);
 512         }
 513         return 0;
 514 }
 515
 516 /*
 517  * cifs_show_options() is for displaying mount options in /proc/mounts.
 518  * Not all settable options are displayed but most of the important
 519  * ones are.
 520  */
 521 static int
 522 cifs_show_options(struct seq_file *s, struct dentry *root)
 523 {
 524         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 525         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 526         struct sockaddr *srcaddr;
 527         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 528
 529         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 530         cifs_show_security(s, tcon->ses);
 531         cifs_show_cache_flavor(s, cifs_sb);
 532
 533         if (tcon->no_lease)
 534                 seq_puts(s, ",nolease");
 535         if (cifs_sb->ctx->multiuser)
 536                 seq_puts(s, ",multiuser");
 537         else if (tcon->ses->user_name)
 538                 seq_show_option(s, "username", tcon->ses->user_name);
 539
 540         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 541                 seq_show_option(s, "domain", tcon->ses->domainName);
 542
 543         if (srcaddr->sa_family != AF_UNSPEC) {
 544                 struct sockaddr_in *saddr4;
 545                 struct sockaddr_in6 *saddr6;
 546                 saddr4 = (struct sockaddr_in *)srcaddr;
 547                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 548                 if (srcaddr->sa_family == AF_INET6)
 549                         seq_printf(s, ",srcaddr=%pI6c",
 550                                    &saddr6->sin6_addr);
 551                 else if (srcaddr->sa_family == AF_INET)
 552                         seq_printf(s, ",srcaddr=%pI4",
 553                                    &saddr4->sin_addr.s_addr);
 554                 else
 555                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 556                                    (int)(srcaddr->sa_family));
 557         }
 558
 559         seq_printf(s, ",uid=%u",
 560                    from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
 561         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 562                 seq_puts(s, ",forceuid");
 563         else
 564                 seq_puts(s, ",noforceuid");
 565
 566         seq_printf(s, ",gid=%u",
 567                    from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
 568         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 569                 seq_puts(s, ",forcegid");
 570         else
 571                 seq_puts(s, ",noforcegid");
 572
 573         cifs_show_address(s, tcon->ses->server);
 574
 575         if (!tcon->unix_ext)
 576                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 577                                            cifs_sb->ctx->file_mode,
 578                                            cifs_sb->ctx->dir_mode);
 579         if (cifs_sb->ctx->iocharset)
 580                 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
 581         if (tcon->seal)
 582                 seq_puts(s, ",seal");
 583         else if (tcon->ses->server->ignore_signature)
 584                 seq_puts(s, ",signloosely");
 585         if (tcon->nocase)
 586                 seq_puts(s, ",nocase");
 587         if (tcon->nodelete)
 588                 seq_puts(s, ",nodelete");
 589         if (cifs_sb->ctx->no_sparse)
 590                 seq_puts(s, ",nosparse");
 591         if (tcon->local_lease)
 592                 seq_puts(s, ",locallease");
 593         if (tcon->retry)
 594                 seq_puts(s, ",hard");
 595         else
 596                 seq_puts(s, ",soft");
 597         if (tcon->use_persistent)
 598                 seq_puts(s, ",persistenthandles");
 599         else if (tcon->use_resilient)
 600                 seq_puts(s, ",resilienthandles");
 601         if (tcon->posix_extensions)
 602                 seq_puts(s, ",posix");
 603         else if (tcon->unix_ext)
 604                 seq_puts(s, ",unix");
 605         else
 606                 seq_puts(s, ",nounix");
 607         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
 608                 seq_puts(s, ",nodfs");
 609         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 610                 seq_puts(s, ",posixpaths");
 611         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 612                 seq_puts(s, ",setuids");
 613         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 614                 seq_puts(s, ",idsfromsid");
 615         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 616                 seq_puts(s, ",serverino");
 617         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 618                 seq_puts(s, ",rwpidforward");
 619         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 620                 seq_puts(s, ",forcemand");
 621         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 622                 seq_puts(s, ",nouser_xattr");
 623         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 624                 seq_puts(s, ",mapchars");
 625         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 626                 seq_puts(s, ",mapposix");
 627         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 628                 seq_puts(s, ",sfu");
 629         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 630                 seq_puts(s, ",nobrl");
 631         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
 632                 seq_puts(s, ",nohandlecache");
 633         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
 634                 seq_puts(s, ",modefromsid");
 635         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 636                 seq_puts(s, ",cifsacl");
 637         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 638                 seq_puts(s, ",dynperm");
 639         if (root->d_sb->s_flags & SB_POSIXACL)
 640                 seq_puts(s, ",acl");
 641         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 642                 seq_puts(s, ",mfsymlinks");
 643         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 644                 seq_puts(s, ",fsc");
 645         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 646                 seq_puts(s, ",nostrictsync");
 647         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 648                 seq_puts(s, ",noperm");
 649         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 650                 seq_printf(s, ",backupuid=%u",
 651                            from_kuid_munged(&init_user_ns,
 652                                             cifs_sb->ctx->backupuid));
 653         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 654                 seq_printf(s, ",backupgid=%u",
 655                            from_kgid_munged(&init_user_ns,
 656                                             cifs_sb->ctx->backupgid));
 657
 658         seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
 659         seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
 660         seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
 661         if (cifs_sb->ctx->rasize)
 662                 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
 663         if (tcon->ses->server->min_offload)
 664                 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
 665         seq_printf(s, ",echo_interval=%lu",
 666                         tcon->ses->server->echo_interval / HZ);
 667
 668         /* Only display max_credits if it was overridden on mount */
 669         if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
 670                 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
 671
 672         if (tcon->snapshot_time)
 673                 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
 674         if (tcon->handle_timeout)
 675                 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
 676
 677         /*
 678          * Display file and directory attribute timeout in seconds.
 679          * If file and directory attribute timeout the same then actimeo
 680          * was likely specified on mount
 681          */
 682         if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
 683                 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
 684         else {
 685                 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
 686                 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
 687         }
 688
 689         if (tcon->ses->chan_max > 1)
 690                 seq_printf(s, ",multichannel,max_channels=%zu",
 691                            tcon->ses->chan_max);
 692
 693         if (tcon->use_witness)
 694                 seq_puts(s, ",witness");
 695
 696         return 0;
 697 }
 698
 699 static void cifs_umount_begin(struct super_block *sb)
 700 {
 701         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 702         struct cifs_tcon *tcon;
 703
 704         if (cifs_sb == NULL)
 705                 return;
 706
 707         tcon = cifs_sb_master_tcon(cifs_sb);
 708
 709         spin_lock(&cifs_tcp_ses_lock);
 710         if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {
 711                 /* we have other mounts to same share or we have
 712                    already tried to force umount this and woken up
 713                    all waiting network requests, nothing to do */
 714                 spin_unlock(&cifs_tcp_ses_lock);
 715                 return;
 716         } else if (tcon->tc_count == 1)
 717                 tcon->status = TID_EXITING;
 718         spin_unlock(&cifs_tcp_ses_lock);
 719
 720         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 721         /* cancel_notify_requests(tcon); */
 722         if (tcon->ses && tcon->ses->server) {
 723                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 724                 wake_up_all(&tcon->ses->server->request_q);
 725                 wake_up_all(&tcon->ses->server->response_q);
 726                 msleep(1); /* yield */
 727                 /* we have to kick the requests once more */
 728                 wake_up_all(&tcon->ses->server->response_q);
 729                 msleep(1);
 730         }
 731
 732         return;
 733 }
 734
 735 #ifdef CONFIG_CIFS_STATS2
 736 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 737 {
 738         /* BB FIXME */
 739         return 0;
 740 }
 741 #endif
 742
 743 static int cifs_drop_inode(struct inode *inode)
 744 {
 745         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 746
 747         /* no serverino => unconditional eviction */
 748         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 749                 generic_drop_inode(inode);
 750 }
 751
 752 static const struct super_operations cifs_super_ops = {
 753         .statfs = cifs_statfs,
 754         .alloc_inode = cifs_alloc_inode,
 755         .free_inode = cifs_free_inode,
 756         .drop_inode     = cifs_drop_inode,
 757         .evict_inode    = cifs_evict_inode,
 758 /*      .show_path      = cifs_show_path, */ /* Would we ever need show path? */
 759         .show_devname   = cifs_show_devname,
 760 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 761         function unless later we add lazy close of inodes or unless the
 762         kernel forgets to call us with the same number of releases (closes)
 763         as opens */
 764         .show_options = cifs_show_options,
 765         .umount_begin   = cifs_umount_begin,
 766 #ifdef CONFIG_CIFS_STATS2
 767         .show_stats = cifs_show_stats,
 768 #endif
 769 };
 770
 771 /*
 772  * Get root dentry from superblock according to prefix path mount option.
 773  * Return dentry with refcount + 1 on success and NULL otherwise.
 774  */
 775 static struct dentry *
 776 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
 777 {
 778         struct dentry *dentry;
 779         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 780         char *full_path = NULL;
 781         char *s, *p;
 782         char sep;
 783
 784         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 785                 return dget(sb->s_root);
 786
 787         full_path = cifs_build_path_to_root(ctx, cifs_sb,
 788                                 cifs_sb_master_tcon(cifs_sb), 0);
 789         if (full_path == NULL)
 790                 return ERR_PTR(-ENOMEM);
 791
 792         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 793
 794         sep = CIFS_DIR_SEP(cifs_sb);
 795         dentry = dget(sb->s_root);
 796         s = full_path;
 797
 798         do {
 799                 struct inode *dir = d_inode(dentry);
 800                 struct dentry *child;
 801
 802                 if (!S_ISDIR(dir->i_mode)) {
 803                         dput(dentry);
 804                         dentry = ERR_PTR(-ENOTDIR);
 805                         break;
 806                 }
 807
 808                 /* skip separators */
 809                 while (*s == sep)
 810                         s++;
 811                 if (!*s)
 812                         break;
 813                 p = s++;
 814                 /* next separator */
 815                 while (*s && *s != sep)
 816                         s++;
 817
 818                 child = lookup_positive_unlocked(p, dentry, s - p);
 819                 dput(dentry);
 820                 dentry = child;
 821         } while (!IS_ERR(dentry));
 822         kfree(full_path);
 823         return dentry;
 824 }
 825
 826 static int cifs_set_super(struct super_block *sb, void *data)
 827 {
 828         struct cifs_mnt_data *mnt_data = data;
 829         sb->s_fs_info = mnt_data->cifs_sb;
 830         return set_anon_super(sb, NULL);
 831 }
 832
 833 struct dentry *
 834 cifs_smb3_do_mount(struct file_system_type *fs_type,
 835               int flags, struct smb3_fs_context *old_ctx)
 836 {
 837         int rc;
 838         struct super_block *sb = NULL;
 839         struct cifs_sb_info *cifs_sb = NULL;
 840         struct cifs_mnt_data mnt_data;
 841         struct dentry *root;
 842
 843         /*
 844          * Prints in Kernel / CIFS log the attempted mount operation
 845          *      If CIFS_DEBUG && cifs_FYI
 846          */
 847         if (cifsFYI)
 848                 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
 849         else
 850                 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
 851
 852         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 853         if (cifs_sb == NULL) {
 854                 root = ERR_PTR(-ENOMEM);
 855                 goto out;
 856         }
 857
 858         cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
 859         if (!cifs_sb->ctx) {
 860                 root = ERR_PTR(-ENOMEM);
 861                 goto out;
 862         }
 863         rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
 864         if (rc) {
 865                 root = ERR_PTR(rc);
 866                 goto out;
 867         }
 868
 869         rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
 870         if (rc) {
 871                 root = ERR_PTR(rc);
 872                 goto out;
 873         }
 874
 875         rc = cifs_setup_cifs_sb(cifs_sb);
 876         if (rc) {
 877                 root = ERR_PTR(rc);
 878                 goto out;
 879         }
 880
 881         rc = cifs_mount(cifs_sb, cifs_sb->ctx);
 882         if (rc) {
 883                 if (!(flags & SB_SILENT))
 884                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 885                                  rc);
 886                 root = ERR_PTR(rc);
 887                 goto out;
 888         }
 889
 890         mnt_data.ctx = cifs_sb->ctx;
 891         mnt_data.cifs_sb = cifs_sb;
 892         mnt_data.flags = flags;
 893
 894         /* BB should we make this contingent on mount parm? */
 895         flags |= SB_NODIRATIME | SB_NOATIME;
 896
 897         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 898         if (IS_ERR(sb)) {
 899                 root = ERR_CAST(sb);
 900                 cifs_umount(cifs_sb);
 901                 cifs_sb = NULL;
 902                 goto out;
 903         }
 904
 905         if (sb->s_root) {
 906                 cifs_dbg(FYI, "Use existing superblock\n");
 907                 cifs_umount(cifs_sb);
 908                 cifs_sb = NULL;
 909         } else {
 910                 rc = cifs_read_super(sb);
 911                 if (rc) {
 912                         root = ERR_PTR(rc);
 913                         goto out_super;
 914                 }
 915
 916                 sb->s_flags |= SB_ACTIVE;
 917         }
 918
 919         root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
 920         if (IS_ERR(root))
 921                 goto out_super;
 922
 923         if (cifs_sb)
 924                 cifs_sb->root = dget(root);
 925
 926         cifs_dbg(FYI, "dentry root is: %p\n", root);
 927         return root;
 928
 929 out_super:
 930         deactivate_locked_super(sb);
 931         return root;
 932 out:
 933         if (cifs_sb) {
 934                 if (!sb || IS_ERR(sb)) {  /* otherwise kill_sb will handle */
 935                         kfree(cifs_sb->prepath);
 936                         smb3_cleanup_fs_context(cifs_sb->ctx);
 937                         kfree(cifs_sb);
 938                 }
 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_flags & IOCB_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 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(&buf_alloc_count, 0);
1580         atomic_set(&small_buf_alloc_count, 0);
1581 #ifdef CONFIG_CIFS_STATS2
1582         atomic_set(&total_buf_alloc_count, 0);
1583         atomic_set(&total_small_buf_alloc_count, 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(&mid_count, 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("md5");
1773 MODULE_SOFTDEP("nls");
1774 MODULE_SOFTDEP("aes");
1775 MODULE_SOFTDEP("cmac");
1776 MODULE_SOFTDEP("sha256");
1777 MODULE_SOFTDEP("sha512");
1778 MODULE_SOFTDEP("aead2");
1779 MODULE_SOFTDEP("ccm");
1780 MODULE_SOFTDEP("gcm");
1781 module_init(init_cifs)
1782 module_exit(exit_cifs)