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