fs/cifs/cifsfs.c

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