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