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 = 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         /*
 878          * Prints in Kernel / CIFS log the attempted mount operation
 879          *      If CIFS_DEBUG && cifs_FYI
 880          */
 881         if (cifsFYI)
 882                 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
 883         else
 884                 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
 885
 886         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 887         if (cifs_sb == NULL) {
 888                 root = ERR_PTR(-ENOMEM);
 889                 goto out;
 890         }
 891
 892         cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
 893         if (!cifs_sb->ctx) {
 894                 root = ERR_PTR(-ENOMEM);
 895                 goto out;
 896         }
 897         rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
 898         if (rc) {
 899                 root = ERR_PTR(rc);
 900                 goto out;
 901         }
 902
 903         rc = cifs_setup_cifs_sb(cifs_sb);
 904         if (rc) {
 905                 root = ERR_PTR(rc);
 906                 goto out;
 907         }
 908
 909         rc = cifs_mount(cifs_sb, cifs_sb->ctx);
 910         if (rc) {
 911                 if (!(flags & SB_SILENT))
 912                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 913                                  rc);
 914                 root = ERR_PTR(rc);
 915                 goto out;
 916         }
 917
 918         mnt_data.ctx = cifs_sb->ctx;
 919         mnt_data.cifs_sb = cifs_sb;
 920         mnt_data.flags = flags;
 921
 922         /* BB should we make this contingent on mount parm? */
 923         flags |= SB_NODIRATIME | SB_NOATIME;
 924
 925         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 926         if (IS_ERR(sb)) {
 927                 root = ERR_CAST(sb);
 928                 cifs_umount(cifs_sb);
 929                 cifs_sb = NULL;
 930                 goto out;
 931         }
 932
 933         if (sb->s_root) {
 934                 cifs_dbg(FYI, "Use existing superblock\n");
 935                 cifs_umount(cifs_sb);
 936                 cifs_sb = NULL;
 937         } else {
 938                 rc = cifs_read_super(sb);
 939                 if (rc) {
 940                         root = ERR_PTR(rc);
 941                         goto out_super;
 942                 }
 943
 944                 sb->s_flags |= SB_ACTIVE;
 945         }
 946
 947         root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
 948         if (IS_ERR(root))
 949                 goto out_super;
 950
 951         if (cifs_sb)
 952                 cifs_sb->root = dget(root);
 953
 954         cifs_dbg(FYI, "dentry root is: %p\n", root);
 955         return root;
 956
 957 out_super:
 958         deactivate_locked_super(sb);
 959         return root;
 960 out:
 961         if (cifs_sb) {
 962                 if (!sb || IS_ERR(sb)) {  /* otherwise kill_sb will handle */
 963                         kfree(cifs_sb->prepath);
 964                         smb3_cleanup_fs_context(cifs_sb->ctx);
 965                         kfree(cifs_sb);
 966                 }
 967         }
 968         return root;
 969 }
 970
 971
 972 static ssize_t
 973 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 974 {
 975         ssize_t rc;
 976         struct inode *inode = file_inode(iocb->ki_filp);
 977
 978         if (iocb->ki_flags & IOCB_DIRECT)
 979                 return cifs_user_readv(iocb, iter);
 980
 981         rc = cifs_revalidate_mapping(inode);
 982         if (rc)
 983                 return rc;
 984
 985         return generic_file_read_iter(iocb, iter);
 986 }
 987
 988 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 989 {
 990         struct inode *inode = file_inode(iocb->ki_filp);
 991         struct cifsInodeInfo *cinode = CIFS_I(inode);
 992         ssize_t written;
 993         int rc;
 994
 995         if (iocb->ki_filp->f_flags & O_DIRECT) {
 996                 written = cifs_user_writev(iocb, from);
 997                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 998                         cifs_zap_mapping(inode);
 999                         cifs_dbg(FYI,
1000                                  "Set no oplock for inode=%p after a write operation\n",
1001                                  inode);
1002                         cinode->oplock = 0;
1003                 }
1004                 return written;
1005         }
1006
1007         written = cifs_get_writer(cinode);
1008         if (written)
1009                 return written;
1010
1011         written = generic_file_write_iter(iocb, from);
1012
1013         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
1014                 goto out;
1015
1016         rc = filemap_fdatawrite(inode->i_mapping);
1017         if (rc)
1018                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
1019                          rc, inode);
1020
1021 out:
1022         cifs_put_writer(cinode);
1023         return written;
1024 }
1025
1026 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1027 {
1028         struct cifsFileInfo *cfile = file->private_data;
1029         struct cifs_tcon *tcon;
1030
1031         /*
1032          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1033          * the cached file length
1034          */
1035         if (whence != SEEK_SET && whence != SEEK_CUR) {
1036                 int rc;
1037                 struct inode *inode = file_inode(file);
1038
1039                 /*
1040                  * We need to be sure that all dirty pages are written and the
1041                  * server has the newest file length.
1042                  */
1043                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1044                     inode->i_mapping->nrpages != 0) {
1045                         rc = filemap_fdatawait(inode->i_mapping);
1046                         if (rc) {
1047                                 mapping_set_error(inode->i_mapping, rc);
1048                                 return rc;
1049                         }
1050                 }
1051                 /*
1052                  * Some applications poll for the file length in this strange
1053                  * way so we must seek to end on non-oplocked files by
1054                  * setting the revalidate time to zero.
1055                  */
1056                 CIFS_I(inode)->time = 0;
1057
1058                 rc = cifs_revalidate_file_attr(file);
1059                 if (rc < 0)
1060                         return (loff_t)rc;
1061         }
1062         if (cfile && cfile->tlink) {
1063                 tcon = tlink_tcon(cfile->tlink);
1064                 if (tcon->ses->server->ops->llseek)
1065                         return tcon->ses->server->ops->llseek(file, tcon,
1066                                                               offset, whence);
1067         }
1068         return generic_file_llseek(file, offset, whence);
1069 }
1070
1071 static int
1072 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1073 {
1074         /*
1075          * Note that this is called by vfs setlease with i_lock held to
1076          * protect *lease from going away.
1077          */
1078         struct inode *inode = file_inode(file);
1079         struct cifsFileInfo *cfile = file->private_data;
1080
1081         if (!(S_ISREG(inode->i_mode)))
1082                 return -EINVAL;
1083
1084         /* Check if file is oplocked if this is request for new lease */
1085         if (arg == F_UNLCK ||
1086             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1087             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1088                 return generic_setlease(file, arg, lease, priv);
1089         else if (tlink_tcon(cfile->tlink)->local_lease &&
1090                  !CIFS_CACHE_READ(CIFS_I(inode)))
1091                 /*
1092                  * If the server claims to support oplock on this file, then we
1093                  * still need to check oplock even if the local_lease mount
1094                  * option is set, but there are servers which do not support
1095                  * oplock for which this mount option may be useful if the user
1096                  * knows that the file won't be changed on the server by anyone
1097                  * else.
1098                  */
1099                 return generic_setlease(file, arg, lease, priv);
1100         else
1101                 return -EAGAIN;
1102 }
1103
1104 struct file_system_type cifs_fs_type = {
1105         .owner = THIS_MODULE,
1106         .name = "cifs",
1107         .init_fs_context = smb3_init_fs_context,
1108         .parameters = smb3_fs_parameters,
1109         .kill_sb = cifs_kill_sb,
1110         .fs_flags = FS_RENAME_DOES_D_MOVE,
1111 };
1112 MODULE_ALIAS_FS("cifs");
1113
1114 struct file_system_type smb3_fs_type = {
1115         .owner = THIS_MODULE,
1116         .name = "smb3",
1117         .init_fs_context = smb3_init_fs_context,
1118         .parameters = smb3_fs_parameters,
1119         .kill_sb = cifs_kill_sb,
1120         .fs_flags = FS_RENAME_DOES_D_MOVE,
1121 };
1122 MODULE_ALIAS_FS("smb3");
1123 MODULE_ALIAS("smb3");
1124
1125 const struct inode_operations cifs_dir_inode_ops = {
1126         .create = cifs_create,
1127         .atomic_open = cifs_atomic_open,
1128         .lookup = cifs_lookup,
1129         .getattr = cifs_getattr,
1130         .unlink = cifs_unlink,
1131         .link = cifs_hardlink,
1132         .mkdir = cifs_mkdir,
1133         .rmdir = cifs_rmdir,
1134         .rename = cifs_rename2,
1135         .permission = cifs_permission,
1136         .setattr = cifs_setattr,
1137         .symlink = cifs_symlink,
1138         .mknod   = cifs_mknod,
1139         .listxattr = cifs_listxattr,
1140         .get_acl = cifs_get_acl,
1141         .set_acl = cifs_set_acl,
1142 };
1143
1144 const struct inode_operations cifs_file_inode_ops = {
1145         .setattr = cifs_setattr,
1146         .getattr = cifs_getattr,
1147         .permission = cifs_permission,
1148         .listxattr = cifs_listxattr,
1149         .fiemap = cifs_fiemap,
1150         .get_acl = cifs_get_acl,
1151         .set_acl = cifs_set_acl,
1152 };
1153
1154 const char *cifs_get_link(struct dentry *dentry, struct inode *inode,
1155                             struct delayed_call *done)
1156 {
1157         char *target_path;
1158
1159         target_path = kmalloc(PATH_MAX, GFP_KERNEL);
1160         if (!target_path)
1161                 return ERR_PTR(-ENOMEM);
1162
1163         spin_lock(&inode->i_lock);
1164         if (likely(CIFS_I(inode)->symlink_target)) {
1165                 strscpy(target_path, CIFS_I(inode)->symlink_target, PATH_MAX);
1166         } else {
1167                 kfree(target_path);
1168                 target_path = ERR_PTR(-EOPNOTSUPP);
1169         }
1170         spin_unlock(&inode->i_lock);
1171
1172         if (!IS_ERR(target_path))
1173                 set_delayed_call(done, kfree_link, target_path);
1174
1175         return target_path;
1176 }
1177
1178 const struct inode_operations cifs_symlink_inode_ops = {
1179         .get_link = cifs_get_link,
1180         .permission = cifs_permission,
1181         .listxattr = cifs_listxattr,
1182 };
1183
1184 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1185                 struct file *dst_file, loff_t destoff, loff_t len,
1186                 unsigned int remap_flags)
1187 {
1188         struct inode *src_inode = file_inode(src_file);
1189         struct inode *target_inode = file_inode(dst_file);
1190         struct cifsFileInfo *smb_file_src = src_file->private_data;
1191         struct cifsFileInfo *smb_file_target;
1192         struct cifs_tcon *target_tcon;
1193         unsigned int xid;
1194         int rc;
1195
1196         if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1197                 return -EINVAL;
1198
1199         cifs_dbg(FYI, "clone range\n");
1200
1201         xid = get_xid();
1202
1203         if (!src_file->private_data || !dst_file->private_data) {
1204                 rc = -EBADF;
1205                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1206                 goto out;
1207         }
1208
1209         smb_file_target = dst_file->private_data;
1210         target_tcon = tlink_tcon(smb_file_target->tlink);
1211
1212         /*
1213          * Note: cifs case is easier than btrfs since server responsible for
1214          * checks for proper open modes and file type and if it wants
1215          * server could even support copy of range where source = target
1216          */
1217         lock_two_nondirectories(target_inode, src_inode);
1218
1219         if (len == 0)
1220                 len = src_inode->i_size - off;
1221
1222         cifs_dbg(FYI, "about to flush pages\n");
1223         /* should we flush first and last page first */
1224         truncate_inode_pages_range(&target_inode->i_data, destoff,
1225                                    PAGE_ALIGN(destoff + len)-1);
1226
1227         if (target_tcon->ses->server->ops->duplicate_extents)
1228                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1229                         smb_file_src, smb_file_target, off, len, destoff);
1230         else
1231                 rc = -EOPNOTSUPP;
1232
1233         /* force revalidate of size and timestamps of target file now
1234            that target is updated on the server */
1235         CIFS_I(target_inode)->time = 0;
1236         /* although unlocking in the reverse order from locking is not
1237            strictly necessary here it is a little cleaner to be consistent */
1238         unlock_two_nondirectories(src_inode, target_inode);
1239 out:
1240         free_xid(xid);
1241         return rc < 0 ? rc : len;
1242 }
1243
1244 ssize_t cifs_file_copychunk_range(unsigned int xid,
1245                                 struct file *src_file, loff_t off,
1246                                 struct file *dst_file, loff_t destoff,
1247                                 size_t len, unsigned int flags)
1248 {
1249         struct inode *src_inode = file_inode(src_file);
1250         struct inode *target_inode = file_inode(dst_file);
1251         struct cifsFileInfo *smb_file_src;
1252         struct cifsFileInfo *smb_file_target;
1253         struct cifs_tcon *src_tcon;
1254         struct cifs_tcon *target_tcon;
1255         ssize_t rc;
1256
1257         cifs_dbg(FYI, "copychunk range\n");
1258
1259         if (!src_file->private_data || !dst_file->private_data) {
1260                 rc = -EBADF;
1261                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1262                 goto out;
1263         }
1264
1265         rc = -EXDEV;
1266         smb_file_target = dst_file->private_data;
1267         smb_file_src = src_file->private_data;
1268         src_tcon = tlink_tcon(smb_file_src->tlink);
1269         target_tcon = tlink_tcon(smb_file_target->tlink);
1270
1271         if (src_tcon->ses != target_tcon->ses) {
1272                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1273                 goto out;
1274         }
1275
1276         rc = -EOPNOTSUPP;
1277         if (!target_tcon->ses->server->ops->copychunk_range)
1278                 goto out;
1279
1280         /*
1281          * Note: cifs case is easier than btrfs since server responsible for
1282          * checks for proper open modes and file type and if it wants
1283          * server could even support copy of range where source = target
1284          */
1285         lock_two_nondirectories(target_inode, src_inode);
1286
1287         cifs_dbg(FYI, "about to flush pages\n");
1288
1289         rc = filemap_write_and_wait_range(src_inode->i_mapping, off,
1290                                           off + len - 1);
1291         if (rc)
1292                 goto unlock;
1293
1294         /* should we flush first and last page first */
1295         truncate_inode_pages(&target_inode->i_data, 0);
1296
1297         rc = file_modified(dst_file);
1298         if (!rc)
1299                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1300                         smb_file_src, smb_file_target, off, len, destoff);
1301
1302         file_accessed(src_file);
1303
1304         /* force revalidate of size and timestamps of target file now
1305          * that target is updated on the server
1306          */
1307         CIFS_I(target_inode)->time = 0;
1308
1309 unlock:
1310         /* although unlocking in the reverse order from locking is not
1311          * strictly necessary here it is a little cleaner to be consistent
1312          */
1313         unlock_two_nondirectories(src_inode, target_inode);
1314
1315 out:
1316         return rc;
1317 }
1318
1319 /*
1320  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1321  * is a dummy operation.
1322  */
1323 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1324 {
1325         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1326                  file, datasync);
1327
1328         return 0;
1329 }
1330
1331 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1332                                 struct file *dst_file, loff_t destoff,
1333                                 size_t len, unsigned int flags)
1334 {
1335         unsigned int xid = get_xid();
1336         ssize_t rc;
1337         struct cifsFileInfo *cfile = dst_file->private_data;
1338
1339         if (cfile->swapfile) {
1340                 rc = -EOPNOTSUPP;
1341                 free_xid(xid);
1342                 return rc;
1343         }
1344
1345         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1346                                         len, flags);
1347         free_xid(xid);
1348
1349         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1350                 rc = generic_copy_file_range(src_file, off, dst_file,
1351                                              destoff, len, flags);
1352         return rc;
1353 }
1354
1355 const struct file_operations cifs_file_ops = {
1356         .read_iter = cifs_loose_read_iter,
1357         .write_iter = cifs_file_write_iter,
1358         .open = cifs_open,
1359         .release = cifs_close,
1360         .lock = cifs_lock,
1361         .flock = cifs_flock,
1362         .fsync = cifs_fsync,
1363         .flush = cifs_flush,
1364         .mmap  = cifs_file_mmap,
1365         .splice_read = cifs_splice_read,
1366         .splice_write = iter_file_splice_write,
1367         .llseek = cifs_llseek,
1368         .unlocked_ioctl = cifs_ioctl,
1369         .copy_file_range = cifs_copy_file_range,
1370         .remap_file_range = cifs_remap_file_range,
1371         .setlease = cifs_setlease,
1372         .fallocate = cifs_fallocate,
1373 };
1374
1375 const struct file_operations cifs_file_strict_ops = {
1376         .read_iter = cifs_strict_readv,
1377         .write_iter = cifs_strict_writev,
1378         .open = cifs_open,
1379         .release = cifs_close,
1380         .lock = cifs_lock,
1381         .flock = cifs_flock,
1382         .fsync = cifs_strict_fsync,
1383         .flush = cifs_flush,
1384         .mmap = cifs_file_strict_mmap,
1385         .splice_read = cifs_splice_read,
1386         .splice_write = iter_file_splice_write,
1387         .llseek = cifs_llseek,
1388         .unlocked_ioctl = cifs_ioctl,
1389         .copy_file_range = cifs_copy_file_range,
1390         .remap_file_range = cifs_remap_file_range,
1391         .setlease = cifs_setlease,
1392         .fallocate = cifs_fallocate,
1393 };
1394
1395 const struct file_operations cifs_file_direct_ops = {
1396         .read_iter = cifs_direct_readv,
1397         .write_iter = cifs_direct_writev,
1398         .open = cifs_open,
1399         .release = cifs_close,
1400         .lock = cifs_lock,
1401         .flock = cifs_flock,
1402         .fsync = cifs_fsync,
1403         .flush = cifs_flush,
1404         .mmap = cifs_file_mmap,
1405         .splice_read = direct_splice_read,
1406         .splice_write = iter_file_splice_write,
1407         .unlocked_ioctl  = cifs_ioctl,
1408         .copy_file_range = cifs_copy_file_range,
1409         .remap_file_range = cifs_remap_file_range,
1410         .llseek = cifs_llseek,
1411         .setlease = cifs_setlease,
1412         .fallocate = cifs_fallocate,
1413 };
1414
1415 const struct file_operations cifs_file_nobrl_ops = {
1416         .read_iter = cifs_loose_read_iter,
1417         .write_iter = cifs_file_write_iter,
1418         .open = cifs_open,
1419         .release = cifs_close,
1420         .fsync = cifs_fsync,
1421         .flush = cifs_flush,
1422         .mmap  = cifs_file_mmap,
1423         .splice_read = cifs_splice_read,
1424         .splice_write = iter_file_splice_write,
1425         .llseek = cifs_llseek,
1426         .unlocked_ioctl = cifs_ioctl,
1427         .copy_file_range = cifs_copy_file_range,
1428         .remap_file_range = cifs_remap_file_range,
1429         .setlease = cifs_setlease,
1430         .fallocate = cifs_fallocate,
1431 };
1432
1433 const struct file_operations cifs_file_strict_nobrl_ops = {
1434         .read_iter = cifs_strict_readv,
1435         .write_iter = cifs_strict_writev,
1436         .open = cifs_open,
1437         .release = cifs_close,
1438         .fsync = cifs_strict_fsync,
1439         .flush = cifs_flush,
1440         .mmap = cifs_file_strict_mmap,
1441         .splice_read = cifs_splice_read,
1442         .splice_write = iter_file_splice_write,
1443         .llseek = cifs_llseek,
1444         .unlocked_ioctl = cifs_ioctl,
1445         .copy_file_range = cifs_copy_file_range,
1446         .remap_file_range = cifs_remap_file_range,
1447         .setlease = cifs_setlease,
1448         .fallocate = cifs_fallocate,
1449 };
1450
1451 const struct file_operations cifs_file_direct_nobrl_ops = {
1452         .read_iter = cifs_direct_readv,
1453         .write_iter = cifs_direct_writev,
1454         .open = cifs_open,
1455         .release = cifs_close,
1456         .fsync = cifs_fsync,
1457         .flush = cifs_flush,
1458         .mmap = cifs_file_mmap,
1459         .splice_read = direct_splice_read,
1460         .splice_write = iter_file_splice_write,
1461         .unlocked_ioctl  = cifs_ioctl,
1462         .copy_file_range = cifs_copy_file_range,
1463         .remap_file_range = cifs_remap_file_range,
1464         .llseek = cifs_llseek,
1465         .setlease = cifs_setlease,
1466         .fallocate = cifs_fallocate,
1467 };
1468
1469 const struct file_operations cifs_dir_ops = {
1470         .iterate_shared = cifs_readdir,
1471         .release = cifs_closedir,
1472         .read    = generic_read_dir,
1473         .unlocked_ioctl  = cifs_ioctl,
1474         .copy_file_range = cifs_copy_file_range,
1475         .remap_file_range = cifs_remap_file_range,
1476         .llseek = generic_file_llseek,
1477         .fsync = cifs_dir_fsync,
1478 };
1479
1480 static void
1481 cifs_init_once(void *inode)
1482 {
1483         struct cifsInodeInfo *cifsi = inode;
1484
1485         inode_init_once(&cifsi->netfs.inode);
1486         init_rwsem(&cifsi->lock_sem);
1487 }
1488
1489 static int __init
1490 cifs_init_inodecache(void)
1491 {
1492         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1493                                               sizeof(struct cifsInodeInfo),
1494                                               0, (SLAB_RECLAIM_ACCOUNT|
1495                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1496                                               cifs_init_once);
1497         if (cifs_inode_cachep == NULL)
1498                 return -ENOMEM;
1499
1500         return 0;
1501 }
1502
1503 static void
1504 cifs_destroy_inodecache(void)
1505 {
1506         /*
1507          * Make sure all delayed rcu free inodes are flushed before we
1508          * destroy cache.
1509          */
1510         rcu_barrier();
1511         kmem_cache_destroy(cifs_inode_cachep);
1512 }
1513
1514 static int
1515 cifs_init_request_bufs(void)
1516 {
1517         /*
1518          * SMB2 maximum header size is bigger than CIFS one - no problems to
1519          * allocate some more bytes for CIFS.
1520          */
1521         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1522
1523         if (CIFSMaxBufSize < 8192) {
1524         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1525         Unicode path name has to fit in any SMB/CIFS path based frames */
1526                 CIFSMaxBufSize = 8192;
1527         } else if (CIFSMaxBufSize > 1024*127) {
1528                 CIFSMaxBufSize = 1024 * 127;
1529         } else {
1530                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1531         }
1532 /*
1533         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1534                  CIFSMaxBufSize, CIFSMaxBufSize);
1535 */
1536         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1537                                             CIFSMaxBufSize + max_hdr_size, 0,
1538                                             SLAB_HWCACHE_ALIGN, 0,
1539                                             CIFSMaxBufSize + max_hdr_size,
1540                                             NULL);
1541         if (cifs_req_cachep == NULL)
1542                 return -ENOMEM;
1543
1544         if (cifs_min_rcv < 1)
1545                 cifs_min_rcv = 1;
1546         else if (cifs_min_rcv > 64) {
1547                 cifs_min_rcv = 64;
1548                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1549         }
1550
1551         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1552                                                   cifs_req_cachep);
1553
1554         if (cifs_req_poolp == NULL) {
1555                 kmem_cache_destroy(cifs_req_cachep);
1556                 return -ENOMEM;
1557         }
1558         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1559         almost all handle based requests (but not write response, nor is it
1560         sufficient for path based requests).  A smaller size would have
1561         been more efficient (compacting multiple slab items on one 4k page)
1562         for the case in which debug was on, but this larger size allows
1563         more SMBs to use small buffer alloc and is still much more
1564         efficient to alloc 1 per page off the slab compared to 17K (5page)
1565         alloc of large cifs buffers even when page debugging is on */
1566         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1567                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1568                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1569         if (cifs_sm_req_cachep == NULL) {
1570                 mempool_destroy(cifs_req_poolp);
1571                 kmem_cache_destroy(cifs_req_cachep);
1572                 return -ENOMEM;
1573         }
1574
1575         if (cifs_min_small < 2)
1576                 cifs_min_small = 2;
1577         else if (cifs_min_small > 256) {
1578                 cifs_min_small = 256;
1579                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1580         }
1581
1582         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1583                                                      cifs_sm_req_cachep);
1584
1585         if (cifs_sm_req_poolp == NULL) {
1586                 mempool_destroy(cifs_req_poolp);
1587                 kmem_cache_destroy(cifs_req_cachep);
1588                 kmem_cache_destroy(cifs_sm_req_cachep);
1589                 return -ENOMEM;
1590         }
1591
1592         return 0;
1593 }
1594
1595 static void
1596 cifs_destroy_request_bufs(void)
1597 {
1598         mempool_destroy(cifs_req_poolp);
1599         kmem_cache_destroy(cifs_req_cachep);
1600         mempool_destroy(cifs_sm_req_poolp);
1601         kmem_cache_destroy(cifs_sm_req_cachep);
1602 }
1603
1604 static int init_mids(void)
1605 {
1606         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1607                                             sizeof(struct mid_q_entry), 0,
1608                                             SLAB_HWCACHE_ALIGN, NULL);
1609         if (cifs_mid_cachep == NULL)
1610                 return -ENOMEM;
1611
1612         /* 3 is a reasonable minimum number of simultaneous operations */
1613         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1614         if (cifs_mid_poolp == NULL) {
1615                 kmem_cache_destroy(cifs_mid_cachep);
1616                 return -ENOMEM;
1617         }
1618
1619         return 0;
1620 }
1621
1622 static void destroy_mids(void)
1623 {
1624         mempool_destroy(cifs_mid_poolp);
1625         kmem_cache_destroy(cifs_mid_cachep);
1626 }
1627
1628 static int __init
1629 init_cifs(void)
1630 {
1631         int rc = 0;
1632         cifs_proc_init();
1633         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1634 /*
1635  *  Initialize Global counters
1636  */
1637         atomic_set(&sesInfoAllocCount, 0);
1638         atomic_set(&tconInfoAllocCount, 0);
1639         atomic_set(&tcpSesNextId, 0);
1640         atomic_set(&tcpSesAllocCount, 0);
1641         atomic_set(&tcpSesReconnectCount, 0);
1642         atomic_set(&tconInfoReconnectCount, 0);
1643
1644         atomic_set(&buf_alloc_count, 0);
1645         atomic_set(&small_buf_alloc_count, 0);
1646 #ifdef CONFIG_CIFS_STATS2
1647         atomic_set(&total_buf_alloc_count, 0);
1648         atomic_set(&total_small_buf_alloc_count, 0);
1649         if (slow_rsp_threshold < 1)
1650                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1651         else if (slow_rsp_threshold > 32767)
1652                 cifs_dbg(VFS,
1653                        "slow response threshold set higher than recommended (0 to 32767)\n");
1654 #endif /* CONFIG_CIFS_STATS2 */
1655
1656         atomic_set(&mid_count, 0);
1657         GlobalCurrentXid = 0;
1658         GlobalTotalActiveXid = 0;
1659         GlobalMaxActiveXid = 0;
1660         spin_lock_init(&cifs_tcp_ses_lock);
1661         spin_lock_init(&GlobalMid_Lock);
1662
1663         cifs_lock_secret = get_random_u32();
1664
1665         if (cifs_max_pending < 2) {
1666                 cifs_max_pending = 2;
1667                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1668         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1669                 cifs_max_pending = CIFS_MAX_REQ;
1670                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1671                          CIFS_MAX_REQ);
1672         }
1673
1674         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1675         if (!cifsiod_wq) {
1676                 rc = -ENOMEM;
1677                 goto out_clean_proc;
1678         }
1679
1680         /*
1681          * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1682          * so that we don't launch too many worker threads but
1683          * Documentation/core-api/workqueue.rst recommends setting it to 0
1684          */
1685
1686         /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1687         decrypt_wq = alloc_workqueue("smb3decryptd",
1688                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1689         if (!decrypt_wq) {
1690                 rc = -ENOMEM;
1691                 goto out_destroy_cifsiod_wq;
1692         }
1693
1694         fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1695                                      WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1696         if (!fileinfo_put_wq) {
1697                 rc = -ENOMEM;
1698                 goto out_destroy_decrypt_wq;
1699         }
1700
1701         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1702                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1703         if (!cifsoplockd_wq) {
1704                 rc = -ENOMEM;
1705                 goto out_destroy_fileinfo_put_wq;
1706         }
1707
1708         deferredclose_wq = alloc_workqueue("deferredclose",
1709                                            WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1710         if (!deferredclose_wq) {
1711                 rc = -ENOMEM;
1712                 goto out_destroy_cifsoplockd_wq;
1713         }
1714
1715         rc = cifs_init_inodecache();
1716         if (rc)
1717                 goto out_destroy_deferredclose_wq;
1718
1719         rc = init_mids();
1720         if (rc)
1721                 goto out_destroy_inodecache;
1722
1723         rc = cifs_init_request_bufs();
1724         if (rc)
1725                 goto out_destroy_mids;
1726
1727 #ifdef CONFIG_CIFS_DFS_UPCALL
1728         rc = dfs_cache_init();
1729         if (rc)
1730                 goto out_destroy_request_bufs;
1731 #endif /* CONFIG_CIFS_DFS_UPCALL */
1732 #ifdef CONFIG_CIFS_UPCALL
1733         rc = init_cifs_spnego();
1734         if (rc)
1735                 goto out_destroy_dfs_cache;
1736 #endif /* CONFIG_CIFS_UPCALL */
1737 #ifdef CONFIG_CIFS_SWN_UPCALL
1738         rc = cifs_genl_init();
1739         if (rc)
1740                 goto out_register_key_type;
1741 #endif /* CONFIG_CIFS_SWN_UPCALL */
1742
1743         rc = init_cifs_idmap();
1744         if (rc)
1745                 goto out_cifs_swn_init;
1746
1747         rc = register_filesystem(&cifs_fs_type);
1748         if (rc)
1749                 goto out_init_cifs_idmap;
1750
1751         rc = register_filesystem(&smb3_fs_type);
1752         if (rc) {
1753                 unregister_filesystem(&cifs_fs_type);
1754                 goto out_init_cifs_idmap;
1755         }
1756
1757         return 0;
1758
1759 out_init_cifs_idmap:
1760         exit_cifs_idmap();
1761 out_cifs_swn_init:
1762 #ifdef CONFIG_CIFS_SWN_UPCALL
1763         cifs_genl_exit();
1764 out_register_key_type:
1765 #endif
1766 #ifdef CONFIG_CIFS_UPCALL
1767         exit_cifs_spnego();
1768 out_destroy_dfs_cache:
1769 #endif
1770 #ifdef CONFIG_CIFS_DFS_UPCALL
1771         dfs_cache_destroy();
1772 out_destroy_request_bufs:
1773 #endif
1774         cifs_destroy_request_bufs();
1775 out_destroy_mids:
1776         destroy_mids();
1777 out_destroy_inodecache:
1778         cifs_destroy_inodecache();
1779 out_destroy_deferredclose_wq:
1780         destroy_workqueue(deferredclose_wq);
1781 out_destroy_cifsoplockd_wq:
1782         destroy_workqueue(cifsoplockd_wq);
1783 out_destroy_fileinfo_put_wq:
1784         destroy_workqueue(fileinfo_put_wq);
1785 out_destroy_decrypt_wq:
1786         destroy_workqueue(decrypt_wq);
1787 out_destroy_cifsiod_wq:
1788         destroy_workqueue(cifsiod_wq);
1789 out_clean_proc:
1790         cifs_proc_clean();
1791         return rc;
1792 }
1793
1794 static void __exit
1795 exit_cifs(void)
1796 {
1797         cifs_dbg(NOISY, "exit_smb3\n");
1798         unregister_filesystem(&cifs_fs_type);
1799         unregister_filesystem(&smb3_fs_type);
1800         cifs_dfs_release_automount_timer();
1801         exit_cifs_idmap();
1802 #ifdef CONFIG_CIFS_SWN_UPCALL
1803         cifs_genl_exit();
1804 #endif
1805 #ifdef CONFIG_CIFS_UPCALL
1806         exit_cifs_spnego();
1807 #endif
1808 #ifdef CONFIG_CIFS_DFS_UPCALL
1809         dfs_cache_destroy();
1810 #endif
1811         cifs_destroy_request_bufs();
1812         destroy_mids();
1813         cifs_destroy_inodecache();
1814         destroy_workqueue(deferredclose_wq);
1815         destroy_workqueue(cifsoplockd_wq);
1816         destroy_workqueue(decrypt_wq);
1817         destroy_workqueue(fileinfo_put_wq);
1818         destroy_workqueue(cifsiod_wq);
1819         cifs_proc_clean();
1820 }
1821
1822 MODULE_AUTHOR("Steve French");
1823 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1824 MODULE_DESCRIPTION
1825         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1826         "also older servers complying with the SNIA CIFS Specification)");
1827 MODULE_VERSION(CIFS_VERSION);
1828 MODULE_SOFTDEP("ecb");
1829 MODULE_SOFTDEP("hmac");
1830 MODULE_SOFTDEP("md5");
1831 MODULE_SOFTDEP("nls");
1832 MODULE_SOFTDEP("aes");
1833 MODULE_SOFTDEP("cmac");
1834 MODULE_SOFTDEP("sha256");
1835 MODULE_SOFTDEP("sha512");
1836 MODULE_SOFTDEP("aead2");
1837 MODULE_SOFTDEP("ccm");
1838 MODULE_SOFTDEP("gcm");
1839 module_init(init_cifs)
1840 module_exit(exit_cifs)