fs/cifs/cifsfs.c

   1 /*
   2  *   fs/cifs/cifsfs.c
   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  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 /* Note that BB means BUGBUG (ie something to fix eventually) */
  25
  26 #include <linux/module.h>
  27 #include <linux/fs.h>
  28 #include <linux/mount.h>
  29 #include <linux/slab.h>
  30 #include <linux/init.h>
  31 #include <linux/list.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/vfs.h>
  34 #include <linux/mempool.h>
  35 #include <linux/delay.h>
  36 #include <linux/kthread.h>
  37 #include <linux/freezer.h>
  38 #include <linux/namei.h>
  39 #include <linux/random.h>
  40 #include <linux/uuid.h>
  41 #include <linux/xattr.h>
  42 #include <net/ipv6.h>
  43 #include "cifsfs.h"
  44 #include "cifspdu.h"
  45 #define DECLARE_GLOBALS_HERE
  46 #include "cifsglob.h"
  47 #include "cifsproto.h"
  48 #include "cifs_debug.h"
  49 #include "cifs_fs_sb.h"
  50 #include <linux/mm.h>
  51 #include <linux/key-type.h>
  52 #include "cifs_spnego.h"
  53 #include "fscache.h"
  54 #include "smb2pdu.h"
  55
  56 int cifsFYI = 0;
  57 bool traceSMB;
  58 bool enable_oplocks = true;
  59 bool linuxExtEnabled = true;
  60 bool lookupCacheEnabled = true;
  61 bool disable_legacy_dialects; /* false by default */
  62 unsigned int global_secflags = CIFSSEC_DEF;
  63 /* unsigned int ntlmv2_support = 0; */
  64 unsigned int sign_CIFS_PDUs = 1;
  65 static const struct super_operations cifs_super_ops;
  66 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  67 module_param(CIFSMaxBufSize, uint, 0444);
  68 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
  69                                  "for CIFS requests. "
  70                                  "Default: 16384 Range: 8192 to 130048");
  71 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  72 module_param(cifs_min_rcv, uint, 0444);
  73 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  74                                 "1 to 64");
  75 unsigned int cifs_min_small = 30;
  76 module_param(cifs_min_small, uint, 0444);
  77 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  78                                  "Range: 2 to 256");
  79 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  80 module_param(cifs_max_pending, uint, 0444);
  81 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
  82                                    "CIFS/SMB1 dialect (N/A for SMB3) "
  83                                    "Default: 32767 Range: 2 to 32767.");
  84 module_param(enable_oplocks, bool, 0644);
  85 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
  86
  87 module_param(disable_legacy_dialects, bool, 0644);
  88 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
  89                                   "helpful to restrict the ability to "
  90                                   "override the default dialects (SMB2.1, "
  91                                   "SMB3 and SMB3.02) on mount with old "
  92                                   "dialects (CIFS/SMB1 and SMB2) since "
  93                                   "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
  94                                   " and less secure. Default: n/N/0");
  95
  96 extern mempool_t *cifs_sm_req_poolp;
  97 extern mempool_t *cifs_req_poolp;
  98 extern mempool_t *cifs_mid_poolp;
  99
 100 struct workqueue_struct *cifsiod_wq;
 101 struct workqueue_struct *cifsoplockd_wq;
 102 __u32 cifs_lock_secret;
 103
 104 /*
 105  * Bumps refcount for cifs super block.
 106  * Note that it should be only called if a referece to VFS super block is
 107  * already held, e.g. in open-type syscalls context. Otherwise it can race with
 108  * atomic_dec_and_test in deactivate_locked_super.
 109  */
 110 void
 111 cifs_sb_active(struct super_block *sb)
 112 {
 113         struct cifs_sb_info *server = CIFS_SB(sb);
 114
 115         if (atomic_inc_return(&server->active) == 1)
 116                 atomic_inc(&sb->s_active);
 117 }
 118
 119 void
 120 cifs_sb_deactive(struct super_block *sb)
 121 {
 122         struct cifs_sb_info *server = CIFS_SB(sb);
 123
 124         if (atomic_dec_and_test(&server->active))
 125                 deactivate_super(sb);
 126 }
 127
 128 static int
 129 cifs_read_super(struct super_block *sb)
 130 {
 131         struct inode *inode;
 132         struct cifs_sb_info *cifs_sb;
 133         struct cifs_tcon *tcon;
 134         int rc = 0;
 135
 136         cifs_sb = CIFS_SB(sb);
 137         tcon = cifs_sb_master_tcon(cifs_sb);
 138
 139         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 140                 sb->s_flags |= SB_POSIXACL;
 141
 142         if (tcon->snapshot_time)
 143                 sb->s_flags |= SB_RDONLY;
 144
 145         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 146                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 147         else
 148                 sb->s_maxbytes = MAX_NON_LFS;
 149
 150         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
 151         sb->s_time_gran = 100;
 152
 153         sb->s_magic = CIFS_MAGIC_NUMBER;
 154         sb->s_op = &cifs_super_ops;
 155         sb->s_xattr = cifs_xattr_handlers;
 156         rc = super_setup_bdi(sb);
 157         if (rc)
 158                 goto out_no_root;
 159         /* tune readahead according to rsize */
 160         sb->s_bdi->ra_pages = cifs_sb->rsize / PAGE_SIZE;
 161
 162         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 163         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 164         inode = cifs_root_iget(sb);
 165
 166         if (IS_ERR(inode)) {
 167                 rc = PTR_ERR(inode);
 168                 goto out_no_root;
 169         }
 170
 171         if (tcon->nocase)
 172                 sb->s_d_op = &cifs_ci_dentry_ops;
 173         else
 174                 sb->s_d_op = &cifs_dentry_ops;
 175
 176         sb->s_root = d_make_root(inode);
 177         if (!sb->s_root) {
 178                 rc = -ENOMEM;
 179                 goto out_no_root;
 180         }
 181
 182 #ifdef CONFIG_CIFS_NFSD_EXPORT
 183         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 184                 cifs_dbg(FYI, "export ops supported\n");
 185                 sb->s_export_op = &cifs_export_ops;
 186         }
 187 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 188
 189         return 0;
 190
 191 out_no_root:
 192         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 193         return rc;
 194 }
 195
 196 static void cifs_kill_sb(struct super_block *sb)
 197 {
 198         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 199         kill_anon_super(sb);
 200         cifs_umount(cifs_sb);
 201 }
 202
 203 static int
 204 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 205 {
 206         struct super_block *sb = dentry->d_sb;
 207         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 208         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 209         struct TCP_Server_Info *server = tcon->ses->server;
 210         unsigned int xid;
 211         int rc = 0;
 212
 213         xid = get_xid();
 214
 215         if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
 216                 buf->f_namelen =
 217                        le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
 218         else
 219                 buf->f_namelen = PATH_MAX;
 220
 221         buf->f_fsid.val[0] = tcon->vol_serial_number;
 222         /* are using part of create time for more randomness, see man statfs */
 223         buf->f_fsid.val[1] =  (int)le64_to_cpu(tcon->vol_create_time);
 224
 225         buf->f_files = 0;       /* undefined */
 226         buf->f_ffree = 0;       /* unlimited */
 227
 228         if (server->ops->queryfs)
 229                 rc = server->ops->queryfs(xid, tcon, buf);
 230
 231         free_xid(xid);
 232         return rc;
 233 }
 234
 235 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 236 {
 237         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 238         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 239         struct TCP_Server_Info *server = tcon->ses->server;
 240
 241         if (server->ops->fallocate)
 242                 return server->ops->fallocate(file, tcon, mode, off, len);
 243
 244         return -EOPNOTSUPP;
 245 }
 246
 247 static int cifs_permission(struct inode *inode, int mask)
 248 {
 249         struct cifs_sb_info *cifs_sb;
 250
 251         cifs_sb = CIFS_SB(inode->i_sb);
 252
 253         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 254                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 255                         return -EACCES;
 256                 else
 257                         return 0;
 258         } else /* file mode might have been restricted at mount time
 259                 on the client (above and beyond ACL on servers) for
 260                 servers which do not support setting and viewing mode bits,
 261                 so allowing client to check permissions is useful */
 262                 return generic_permission(inode, mask);
 263 }
 264
 265 static struct kmem_cache *cifs_inode_cachep;
 266 static struct kmem_cache *cifs_req_cachep;
 267 static struct kmem_cache *cifs_mid_cachep;
 268 static struct kmem_cache *cifs_sm_req_cachep;
 269 mempool_t *cifs_sm_req_poolp;
 270 mempool_t *cifs_req_poolp;
 271 mempool_t *cifs_mid_poolp;
 272
 273 static struct inode *
 274 cifs_alloc_inode(struct super_block *sb)
 275 {
 276         struct cifsInodeInfo *cifs_inode;
 277         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 278         if (!cifs_inode)
 279                 return NULL;
 280         cifs_inode->cifsAttrs = 0x20;   /* default */
 281         cifs_inode->time = 0;
 282         /*
 283          * Until the file is open and we have gotten oplock info back from the
 284          * server, can not assume caching of file data or metadata.
 285          */
 286         cifs_set_oplock_level(cifs_inode, 0);
 287         cifs_inode->flags = 0;
 288         spin_lock_init(&cifs_inode->writers_lock);
 289         cifs_inode->writers = 0;
 290         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 291         cifs_inode->server_eof = 0;
 292         cifs_inode->uniqueid = 0;
 293         cifs_inode->createtime = 0;
 294         cifs_inode->epoch = 0;
 295         spin_lock_init(&cifs_inode->open_file_lock);
 296         generate_random_uuid(cifs_inode->lease_key);
 297
 298         /*
 299          * Can not set i_flags here - they get immediately overwritten to zero
 300          * by the VFS.
 301          */
 302         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 303         INIT_LIST_HEAD(&cifs_inode->openFileList);
 304         INIT_LIST_HEAD(&cifs_inode->llist);
 305         return &cifs_inode->vfs_inode;
 306 }
 307
 308 static void cifs_i_callback(struct rcu_head *head)
 309 {
 310         struct inode *inode = container_of(head, struct inode, i_rcu);
 311         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 312 }
 313
 314 static void
 315 cifs_destroy_inode(struct inode *inode)
 316 {
 317         call_rcu(&inode->i_rcu, cifs_i_callback);
 318 }
 319
 320 static void
 321 cifs_evict_inode(struct inode *inode)
 322 {
 323         truncate_inode_pages_final(&inode->i_data);
 324         clear_inode(inode);
 325         cifs_fscache_release_inode_cookie(inode);
 326 }
 327
 328 static void
 329 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 330 {
 331         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 332         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 333
 334         seq_puts(s, ",addr=");
 335
 336         switch (server->dstaddr.ss_family) {
 337         case AF_INET:
 338                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 339                 break;
 340         case AF_INET6:
 341                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 342                 if (sa6->sin6_scope_id)
 343                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 344                 break;
 345         default:
 346                 seq_puts(s, "(unknown)");
 347         }
 348         if (server->rdma)
 349                 seq_puts(s, ",rdma");
 350 }
 351
 352 static void
 353 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 354 {
 355         if (ses->sectype == Unspecified) {
 356                 if (ses->user_name == NULL)
 357                         seq_puts(s, ",sec=none");
 358                 return;
 359         }
 360
 361         seq_puts(s, ",sec=");
 362
 363         switch (ses->sectype) {
 364         case LANMAN:
 365                 seq_puts(s, "lanman");
 366                 break;
 367         case NTLMv2:
 368                 seq_puts(s, "ntlmv2");
 369                 break;
 370         case NTLM:
 371                 seq_puts(s, "ntlm");
 372                 break;
 373         case Kerberos:
 374                 seq_puts(s, "krb5");
 375                 break;
 376         case RawNTLMSSP:
 377                 seq_puts(s, "ntlmssp");
 378                 break;
 379         default:
 380                 /* shouldn't ever happen */
 381                 seq_puts(s, "unknown");
 382                 break;
 383         }
 384
 385         if (ses->sign)
 386                 seq_puts(s, "i");
 387 }
 388
 389 static void
 390 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 391 {
 392         seq_puts(s, ",cache=");
 393
 394         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 395                 seq_puts(s, "strict");
 396         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 397                 seq_puts(s, "none");
 398         else
 399                 seq_puts(s, "loose");
 400 }
 401
 402 static void
 403 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
 404 {
 405         struct nls_table *def;
 406
 407         /* Display iocharset= option if it's not default charset */
 408         def = load_nls_default();
 409         if (def != cur)
 410                 seq_printf(s, ",iocharset=%s", cur->charset);
 411         unload_nls(def);
 412 }
 413
 414 /*
 415  * cifs_show_options() is for displaying mount options in /proc/mounts.
 416  * Not all settable options are displayed but most of the important
 417  * ones are.
 418  */
 419 static int
 420 cifs_show_options(struct seq_file *s, struct dentry *root)
 421 {
 422         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 423         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 424         struct sockaddr *srcaddr;
 425         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 426
 427         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 428         cifs_show_security(s, tcon->ses);
 429         cifs_show_cache_flavor(s, cifs_sb);
 430
 431         if (tcon->no_lease)
 432                 seq_puts(s, ",nolease");
 433         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 434                 seq_puts(s, ",multiuser");
 435         else if (tcon->ses->user_name)
 436                 seq_show_option(s, "username", tcon->ses->user_name);
 437
 438         if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
 439                 seq_show_option(s, "domain", tcon->ses->domainName);
 440
 441         if (srcaddr->sa_family != AF_UNSPEC) {
 442                 struct sockaddr_in *saddr4;
 443                 struct sockaddr_in6 *saddr6;
 444                 saddr4 = (struct sockaddr_in *)srcaddr;
 445                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 446                 if (srcaddr->sa_family == AF_INET6)
 447                         seq_printf(s, ",srcaddr=%pI6c",
 448                                    &saddr6->sin6_addr);
 449                 else if (srcaddr->sa_family == AF_INET)
 450                         seq_printf(s, ",srcaddr=%pI4",
 451                                    &saddr4->sin_addr.s_addr);
 452                 else
 453                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 454                                    (int)(srcaddr->sa_family));
 455         }
 456
 457         seq_printf(s, ",uid=%u",
 458                    from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
 459         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 460                 seq_puts(s, ",forceuid");
 461         else
 462                 seq_puts(s, ",noforceuid");
 463
 464         seq_printf(s, ",gid=%u",
 465                    from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
 466         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 467                 seq_puts(s, ",forcegid");
 468         else
 469                 seq_puts(s, ",noforcegid");
 470
 471         cifs_show_address(s, tcon->ses->server);
 472
 473         if (!tcon->unix_ext)
 474                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 475                                            cifs_sb->mnt_file_mode,
 476                                            cifs_sb->mnt_dir_mode);
 477
 478         cifs_show_nls(s, cifs_sb->local_nls);
 479
 480         if (tcon->seal)
 481                 seq_puts(s, ",seal");
 482         if (tcon->nocase)
 483                 seq_puts(s, ",nocase");
 484         if (tcon->retry)
 485                 seq_puts(s, ",hard");
 486         else
 487                 seq_puts(s, ",soft");
 488         if (tcon->use_persistent)
 489                 seq_puts(s, ",persistenthandles");
 490         else if (tcon->use_resilient)
 491                 seq_puts(s, ",resilienthandles");
 492         if (tcon->posix_extensions)
 493                 seq_puts(s, ",posix");
 494         else if (tcon->unix_ext)
 495                 seq_puts(s, ",unix");
 496         else
 497                 seq_puts(s, ",nounix");
 498         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 499                 seq_puts(s, ",posixpaths");
 500         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 501                 seq_puts(s, ",setuids");
 502         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 503                 seq_puts(s, ",idsfromsid");
 504         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 505                 seq_puts(s, ",serverino");
 506         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 507                 seq_puts(s, ",rwpidforward");
 508         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 509                 seq_puts(s, ",forcemand");
 510         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 511                 seq_puts(s, ",nouser_xattr");
 512         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 513                 seq_puts(s, ",mapchars");
 514         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 515                 seq_puts(s, ",mapposix");
 516         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 517                 seq_puts(s, ",sfu");
 518         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 519                 seq_puts(s, ",nobrl");
 520         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
 521                 seq_puts(s, ",nohandlecache");
 522         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 523                 seq_puts(s, ",cifsacl");
 524         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 525                 seq_puts(s, ",dynperm");
 526         if (root->d_sb->s_flags & SB_POSIXACL)
 527                 seq_puts(s, ",acl");
 528         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 529                 seq_puts(s, ",mfsymlinks");
 530         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 531                 seq_puts(s, ",fsc");
 532         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 533                 seq_puts(s, ",nostrictsync");
 534         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 535                 seq_puts(s, ",noperm");
 536         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 537                 seq_printf(s, ",backupuid=%u",
 538                            from_kuid_munged(&init_user_ns,
 539                                             cifs_sb->mnt_backupuid));
 540         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 541                 seq_printf(s, ",backupgid=%u",
 542                            from_kgid_munged(&init_user_ns,
 543                                             cifs_sb->mnt_backupgid));
 544
 545         seq_printf(s, ",rsize=%u", cifs_sb->rsize);
 546         seq_printf(s, ",wsize=%u", cifs_sb->wsize);
 547         seq_printf(s, ",echo_interval=%lu",
 548                         tcon->ses->server->echo_interval / HZ);
 549         if (tcon->snapshot_time)
 550                 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
 551         /* convert actimeo and display it in seconds */
 552         seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 553
 554         return 0;
 555 }
 556
 557 static void cifs_umount_begin(struct super_block *sb)
 558 {
 559         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 560         struct cifs_tcon *tcon;
 561
 562         if (cifs_sb == NULL)
 563                 return;
 564
 565         tcon = cifs_sb_master_tcon(cifs_sb);
 566
 567         spin_lock(&cifs_tcp_ses_lock);
 568         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 569                 /* we have other mounts to same share or we have
 570                    already tried to force umount this and woken up
 571                    all waiting network requests, nothing to do */
 572                 spin_unlock(&cifs_tcp_ses_lock);
 573                 return;
 574         } else if (tcon->tc_count == 1)
 575                 tcon->tidStatus = CifsExiting;
 576         spin_unlock(&cifs_tcp_ses_lock);
 577
 578         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 579         /* cancel_notify_requests(tcon); */
 580         if (tcon->ses && tcon->ses->server) {
 581                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 582                 wake_up_all(&tcon->ses->server->request_q);
 583                 wake_up_all(&tcon->ses->server->response_q);
 584                 msleep(1); /* yield */
 585                 /* we have to kick the requests once more */
 586                 wake_up_all(&tcon->ses->server->response_q);
 587                 msleep(1);
 588         }
 589
 590         return;
 591 }
 592
 593 #ifdef CONFIG_CIFS_STATS2
 594 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 595 {
 596         /* BB FIXME */
 597         return 0;
 598 }
 599 #endif
 600
 601 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 602 {
 603         sync_filesystem(sb);
 604         *flags |= SB_NODIRATIME;
 605         return 0;
 606 }
 607
 608 static int cifs_drop_inode(struct inode *inode)
 609 {
 610         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 611
 612         /* no serverino => unconditional eviction */
 613         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 614                 generic_drop_inode(inode);
 615 }
 616
 617 static const struct super_operations cifs_super_ops = {
 618         .statfs = cifs_statfs,
 619         .alloc_inode = cifs_alloc_inode,
 620         .destroy_inode = cifs_destroy_inode,
 621         .drop_inode     = cifs_drop_inode,
 622         .evict_inode    = cifs_evict_inode,
 623 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 624         function unless later we add lazy close of inodes or unless the
 625         kernel forgets to call us with the same number of releases (closes)
 626         as opens */
 627         .show_options = cifs_show_options,
 628         .umount_begin   = cifs_umount_begin,
 629         .remount_fs = cifs_remount,
 630 #ifdef CONFIG_CIFS_STATS2
 631         .show_stats = cifs_show_stats,
 632 #endif
 633 };
 634
 635 /*
 636  * Get root dentry from superblock according to prefix path mount option.
 637  * Return dentry with refcount + 1 on success and NULL otherwise.
 638  */
 639 static struct dentry *
 640 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 641 {
 642         struct dentry *dentry;
 643         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 644         char *full_path = NULL;
 645         char *s, *p;
 646         char sep;
 647
 648         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 649                 return dget(sb->s_root);
 650
 651         full_path = cifs_build_path_to_root(vol, cifs_sb,
 652                                 cifs_sb_master_tcon(cifs_sb), 0);
 653         if (full_path == NULL)
 654                 return ERR_PTR(-ENOMEM);
 655
 656         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 657
 658         sep = CIFS_DIR_SEP(cifs_sb);
 659         dentry = dget(sb->s_root);
 660         p = s = full_path;
 661
 662         do {
 663                 struct inode *dir = d_inode(dentry);
 664                 struct dentry *child;
 665
 666                 if (!dir) {
 667                         dput(dentry);
 668                         dentry = ERR_PTR(-ENOENT);
 669                         break;
 670                 }
 671                 if (!S_ISDIR(dir->i_mode)) {
 672                         dput(dentry);
 673                         dentry = ERR_PTR(-ENOTDIR);
 674                         break;
 675                 }
 676
 677                 /* skip separators */
 678                 while (*s == sep)
 679                         s++;
 680                 if (!*s)
 681                         break;
 682                 p = s++;
 683                 /* next separator */
 684                 while (*s && *s != sep)
 685                         s++;
 686
 687                 child = lookup_one_len_unlocked(p, dentry, s - p);
 688                 dput(dentry);
 689                 dentry = child;
 690         } while (!IS_ERR(dentry));
 691         kfree(full_path);
 692         return dentry;
 693 }
 694
 695 static int cifs_set_super(struct super_block *sb, void *data)
 696 {
 697         struct cifs_mnt_data *mnt_data = data;
 698         sb->s_fs_info = mnt_data->cifs_sb;
 699         return set_anon_super(sb, NULL);
 700 }
 701
 702 static struct dentry *
 703 cifs_smb3_do_mount(struct file_system_type *fs_type,
 704               int flags, const char *dev_name, void *data, bool is_smb3)
 705 {
 706         int rc;
 707         struct super_block *sb;
 708         struct cifs_sb_info *cifs_sb;
 709         struct smb_vol *volume_info;
 710         struct cifs_mnt_data mnt_data;
 711         struct dentry *root;
 712
 713         cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
 714
 715         volume_info = cifs_get_volume_info((char *)data, dev_name, is_smb3);
 716         if (IS_ERR(volume_info))
 717                 return ERR_CAST(volume_info);
 718
 719         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 720         if (cifs_sb == NULL) {
 721                 root = ERR_PTR(-ENOMEM);
 722                 goto out_nls;
 723         }
 724
 725         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 726         if (cifs_sb->mountdata == NULL) {
 727                 root = ERR_PTR(-ENOMEM);
 728                 goto out_free;
 729         }
 730
 731         rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
 732         if (rc) {
 733                 root = ERR_PTR(rc);
 734                 goto out_free;
 735         }
 736
 737         rc = cifs_mount(cifs_sb, volume_info);
 738         if (rc) {
 739                 if (!(flags & SB_SILENT))
 740                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 741                                  rc);
 742                 root = ERR_PTR(rc);
 743                 goto out_free;
 744         }
 745
 746         mnt_data.vol = volume_info;
 747         mnt_data.cifs_sb = cifs_sb;
 748         mnt_data.flags = flags;
 749
 750         /* BB should we make this contingent on mount parm? */
 751         flags |= SB_NODIRATIME | SB_NOATIME;
 752
 753         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 754         if (IS_ERR(sb)) {
 755                 root = ERR_CAST(sb);
 756                 cifs_umount(cifs_sb);
 757                 goto out;
 758         }
 759
 760         if (sb->s_root) {
 761                 cifs_dbg(FYI, "Use existing superblock\n");
 762                 cifs_umount(cifs_sb);
 763         } else {
 764                 rc = cifs_read_super(sb);
 765                 if (rc) {
 766                         root = ERR_PTR(rc);
 767                         goto out_super;
 768                 }
 769
 770                 sb->s_flags |= SB_ACTIVE;
 771         }
 772
 773         root = cifs_get_root(volume_info, sb);
 774         if (IS_ERR(root))
 775                 goto out_super;
 776
 777         cifs_dbg(FYI, "dentry root is: %p\n", root);
 778         goto out;
 779
 780 out_super:
 781         deactivate_locked_super(sb);
 782         return root;
 783 out:
 784         cifs_cleanup_volume_info(volume_info);
 785         return root;
 786
 787 out_free:
 788         kfree(cifs_sb->prepath);
 789         kfree(cifs_sb->mountdata);
 790         kfree(cifs_sb);
 791 out_nls:
 792         unload_nls(volume_info->local_nls);
 793         goto out;
 794 }
 795
 796 static struct dentry *
 797 smb3_do_mount(struct file_system_type *fs_type,
 798               int flags, const char *dev_name, void *data)
 799 {
 800         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, true);
 801 }
 802
 803 static struct dentry *
 804 cifs_do_mount(struct file_system_type *fs_type,
 805               int flags, const char *dev_name, void *data)
 806 {
 807         return cifs_smb3_do_mount(fs_type, flags, dev_name, data, false);
 808 }
 809
 810 static ssize_t
 811 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 812 {
 813         ssize_t rc;
 814         struct inode *inode = file_inode(iocb->ki_filp);
 815
 816         if (iocb->ki_flags & IOCB_DIRECT)
 817                 return cifs_user_readv(iocb, iter);
 818
 819         rc = cifs_revalidate_mapping(inode);
 820         if (rc)
 821                 return rc;
 822
 823         return generic_file_read_iter(iocb, iter);
 824 }
 825
 826 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 827 {
 828         struct inode *inode = file_inode(iocb->ki_filp);
 829         struct cifsInodeInfo *cinode = CIFS_I(inode);
 830         ssize_t written;
 831         int rc;
 832
 833         if (iocb->ki_filp->f_flags & O_DIRECT) {
 834                 written = cifs_user_writev(iocb, from);
 835                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 836                         cifs_zap_mapping(inode);
 837                         cifs_dbg(FYI,
 838                                  "Set no oplock for inode=%p after a write operation\n",
 839                                  inode);
 840                         cinode->oplock = 0;
 841                 }
 842                 return written;
 843         }
 844
 845         written = cifs_get_writer(cinode);
 846         if (written)
 847                 return written;
 848
 849         written = generic_file_write_iter(iocb, from);
 850
 851         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 852                 goto out;
 853
 854         rc = filemap_fdatawrite(inode->i_mapping);
 855         if (rc)
 856                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 857                          rc, inode);
 858
 859 out:
 860         cifs_put_writer(cinode);
 861         return written;
 862 }
 863
 864 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 865 {
 866         /*
 867          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 868          * the cached file length
 869          */
 870         if (whence != SEEK_SET && whence != SEEK_CUR) {
 871                 int rc;
 872                 struct inode *inode = file_inode(file);
 873
 874                 /*
 875                  * We need to be sure that all dirty pages are written and the
 876                  * server has the newest file length.
 877                  */
 878                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 879                     inode->i_mapping->nrpages != 0) {
 880                         rc = filemap_fdatawait(inode->i_mapping);
 881                         if (rc) {
 882                                 mapping_set_error(inode->i_mapping, rc);
 883                                 return rc;
 884                         }
 885                 }
 886                 /*
 887                  * Some applications poll for the file length in this strange
 888                  * way so we must seek to end on non-oplocked files by
 889                  * setting the revalidate time to zero.
 890                  */
 891                 CIFS_I(inode)->time = 0;
 892
 893                 rc = cifs_revalidate_file_attr(file);
 894                 if (rc < 0)
 895                         return (loff_t)rc;
 896         }
 897         return generic_file_llseek(file, offset, whence);
 898 }
 899
 900 static int
 901 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 902 {
 903         /*
 904          * Note that this is called by vfs setlease with i_lock held to
 905          * protect *lease from going away.
 906          */
 907         struct inode *inode = file_inode(file);
 908         struct cifsFileInfo *cfile = file->private_data;
 909
 910         if (!(S_ISREG(inode->i_mode)))
 911                 return -EINVAL;
 912
 913         /* Check if file is oplocked if this is request for new lease */
 914         if (arg == F_UNLCK ||
 915             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 916             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 917                 return generic_setlease(file, arg, lease, priv);
 918         else if (tlink_tcon(cfile->tlink)->local_lease &&
 919                  !CIFS_CACHE_READ(CIFS_I(inode)))
 920                 /*
 921                  * If the server claims to support oplock on this file, then we
 922                  * still need to check oplock even if the local_lease mount
 923                  * option is set, but there are servers which do not support
 924                  * oplock for which this mount option may be useful if the user
 925                  * knows that the file won't be changed on the server by anyone
 926                  * else.
 927                  */
 928                 return generic_setlease(file, arg, lease, priv);
 929         else
 930                 return -EAGAIN;
 931 }
 932
 933 struct file_system_type cifs_fs_type = {
 934         .owner = THIS_MODULE,
 935         .name = "cifs",
 936         .mount = cifs_do_mount,
 937         .kill_sb = cifs_kill_sb,
 938         /*  .fs_flags */
 939 };
 940 MODULE_ALIAS_FS("cifs");
 941
 942 static struct file_system_type smb3_fs_type = {
 943         .owner = THIS_MODULE,
 944         .name = "smb3",
 945         .mount = smb3_do_mount,
 946         .kill_sb = cifs_kill_sb,
 947         /*  .fs_flags */
 948 };
 949 MODULE_ALIAS_FS("smb3");
 950 MODULE_ALIAS("smb3");
 951
 952 const struct inode_operations cifs_dir_inode_ops = {
 953         .create = cifs_create,
 954         .atomic_open = cifs_atomic_open,
 955         .lookup = cifs_lookup,
 956         .getattr = cifs_getattr,
 957         .unlink = cifs_unlink,
 958         .link = cifs_hardlink,
 959         .mkdir = cifs_mkdir,
 960         .rmdir = cifs_rmdir,
 961         .rename = cifs_rename2,
 962         .permission = cifs_permission,
 963         .setattr = cifs_setattr,
 964         .symlink = cifs_symlink,
 965         .mknod   = cifs_mknod,
 966         .listxattr = cifs_listxattr,
 967 };
 968
 969 const struct inode_operations cifs_file_inode_ops = {
 970         .setattr = cifs_setattr,
 971         .getattr = cifs_getattr,
 972         .permission = cifs_permission,
 973         .listxattr = cifs_listxattr,
 974 };
 975
 976 const struct inode_operations cifs_symlink_inode_ops = {
 977         .get_link = cifs_get_link,
 978         .permission = cifs_permission,
 979         .listxattr = cifs_listxattr,
 980 };
 981
 982 static int cifs_clone_file_range(struct file *src_file, loff_t off,
 983                 struct file *dst_file, loff_t destoff, u64 len)
 984 {
 985         struct inode *src_inode = file_inode(src_file);
 986         struct inode *target_inode = file_inode(dst_file);
 987         struct cifsFileInfo *smb_file_src = src_file->private_data;
 988         struct cifsFileInfo *smb_file_target;
 989         struct cifs_tcon *target_tcon;
 990         unsigned int xid;
 991         int rc;
 992
 993         cifs_dbg(FYI, "clone range\n");
 994
 995         xid = get_xid();
 996
 997         if (!src_file->private_data || !dst_file->private_data) {
 998                 rc = -EBADF;
 999                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1000                 goto out;
1001         }
1002
1003         smb_file_target = dst_file->private_data;
1004         target_tcon = tlink_tcon(smb_file_target->tlink);
1005
1006         /*
1007          * Note: cifs case is easier than btrfs since server responsible for
1008          * checks for proper open modes and file type and if it wants
1009          * server could even support copy of range where source = target
1010          */
1011         lock_two_nondirectories(target_inode, src_inode);
1012
1013         if (len == 0)
1014                 len = src_inode->i_size - off;
1015
1016         cifs_dbg(FYI, "about to flush pages\n");
1017         /* should we flush first and last page first */
1018         truncate_inode_pages_range(&target_inode->i_data, destoff,
1019                                    PAGE_ALIGN(destoff + len)-1);
1020
1021         if (target_tcon->ses->server->ops->duplicate_extents)
1022                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1023                         smb_file_src, smb_file_target, off, len, destoff);
1024         else
1025                 rc = -EOPNOTSUPP;
1026
1027         /* force revalidate of size and timestamps of target file now
1028            that target is updated on the server */
1029         CIFS_I(target_inode)->time = 0;
1030         /* although unlocking in the reverse order from locking is not
1031            strictly necessary here it is a little cleaner to be consistent */
1032         unlock_two_nondirectories(src_inode, target_inode);
1033 out:
1034         free_xid(xid);
1035         return rc;
1036 }
1037
1038 ssize_t cifs_file_copychunk_range(unsigned int xid,
1039                                 struct file *src_file, loff_t off,
1040                                 struct file *dst_file, loff_t destoff,
1041                                 size_t len, unsigned int flags)
1042 {
1043         struct inode *src_inode = file_inode(src_file);
1044         struct inode *target_inode = file_inode(dst_file);
1045         struct cifsFileInfo *smb_file_src;
1046         struct cifsFileInfo *smb_file_target;
1047         struct cifs_tcon *src_tcon;
1048         struct cifs_tcon *target_tcon;
1049         ssize_t rc;
1050
1051         cifs_dbg(FYI, "copychunk range\n");
1052
1053         if (src_inode == target_inode) {
1054                 rc = -EINVAL;
1055                 goto out;
1056         }
1057
1058         if (!src_file->private_data || !dst_file->private_data) {
1059                 rc = -EBADF;
1060                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1061                 goto out;
1062         }
1063
1064         rc = -EXDEV;
1065         smb_file_target = dst_file->private_data;
1066         smb_file_src = src_file->private_data;
1067         src_tcon = tlink_tcon(smb_file_src->tlink);
1068         target_tcon = tlink_tcon(smb_file_target->tlink);
1069
1070         if (src_tcon->ses != target_tcon->ses) {
1071                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1072                 goto out;
1073         }
1074
1075         /*
1076          * Note: cifs case is easier than btrfs since server responsible for
1077          * checks for proper open modes and file type and if it wants
1078          * server could even support copy of range where source = target
1079          */
1080         lock_two_nondirectories(target_inode, src_inode);
1081
1082         cifs_dbg(FYI, "about to flush pages\n");
1083         /* should we flush first and last page first */
1084         truncate_inode_pages(&target_inode->i_data, 0);
1085
1086         if (target_tcon->ses->server->ops->copychunk_range)
1087                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1088                         smb_file_src, smb_file_target, off, len, destoff);
1089         else
1090                 rc = -EOPNOTSUPP;
1091
1092         /* force revalidate of size and timestamps of target file now
1093          * that target is updated on the server
1094          */
1095         CIFS_I(target_inode)->time = 0;
1096         /* although unlocking in the reverse order from locking is not
1097          * strictly necessary here it is a little cleaner to be consistent
1098          */
1099         unlock_two_nondirectories(src_inode, target_inode);
1100
1101 out:
1102         return rc;
1103 }
1104
1105 /*
1106  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1107  * is a dummy operation.
1108  */
1109 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1110 {
1111         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1112                  file, datasync);
1113
1114         return 0;
1115 }
1116
1117 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1118                                 struct file *dst_file, loff_t destoff,
1119                                 size_t len, unsigned int flags)
1120 {
1121         unsigned int xid = get_xid();
1122         ssize_t rc;
1123
1124         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1125                                         len, flags);
1126         free_xid(xid);
1127         return rc;
1128 }
1129
1130 const struct file_operations cifs_file_ops = {
1131         .read_iter = cifs_loose_read_iter,
1132         .write_iter = cifs_file_write_iter,
1133         .open = cifs_open,
1134         .release = cifs_close,
1135         .lock = cifs_lock,
1136         .fsync = cifs_fsync,
1137         .flush = cifs_flush,
1138         .mmap  = cifs_file_mmap,
1139         .splice_read = generic_file_splice_read,
1140         .splice_write = iter_file_splice_write,
1141         .llseek = cifs_llseek,
1142         .unlocked_ioctl = cifs_ioctl,
1143         .copy_file_range = cifs_copy_file_range,
1144         .clone_file_range = cifs_clone_file_range,
1145         .setlease = cifs_setlease,
1146         .fallocate = cifs_fallocate,
1147 };
1148
1149 const struct file_operations cifs_file_strict_ops = {
1150         .read_iter = cifs_strict_readv,
1151         .write_iter = cifs_strict_writev,
1152         .open = cifs_open,
1153         .release = cifs_close,
1154         .lock = cifs_lock,
1155         .fsync = cifs_strict_fsync,
1156         .flush = cifs_flush,
1157         .mmap = cifs_file_strict_mmap,
1158         .splice_read = generic_file_splice_read,
1159         .splice_write = iter_file_splice_write,
1160         .llseek = cifs_llseek,
1161         .unlocked_ioctl = cifs_ioctl,
1162         .copy_file_range = cifs_copy_file_range,
1163         .clone_file_range = cifs_clone_file_range,
1164         .setlease = cifs_setlease,
1165         .fallocate = cifs_fallocate,
1166 };
1167
1168 const struct file_operations cifs_file_direct_ops = {
1169         /* BB reevaluate whether they can be done with directio, no cache */
1170         .read_iter = cifs_user_readv,
1171         .write_iter = cifs_user_writev,
1172         .open = cifs_open,
1173         .release = cifs_close,
1174         .lock = cifs_lock,
1175         .fsync = cifs_fsync,
1176         .flush = cifs_flush,
1177         .mmap = cifs_file_mmap,
1178         .splice_read = generic_file_splice_read,
1179         .splice_write = iter_file_splice_write,
1180         .unlocked_ioctl  = cifs_ioctl,
1181         .copy_file_range = cifs_copy_file_range,
1182         .clone_file_range = cifs_clone_file_range,
1183         .llseek = cifs_llseek,
1184         .setlease = cifs_setlease,
1185         .fallocate = cifs_fallocate,
1186 };
1187
1188 const struct file_operations cifs_file_nobrl_ops = {
1189         .read_iter = cifs_loose_read_iter,
1190         .write_iter = cifs_file_write_iter,
1191         .open = cifs_open,
1192         .release = cifs_close,
1193         .fsync = cifs_fsync,
1194         .flush = cifs_flush,
1195         .mmap  = cifs_file_mmap,
1196         .splice_read = generic_file_splice_read,
1197         .splice_write = iter_file_splice_write,
1198         .llseek = cifs_llseek,
1199         .unlocked_ioctl = cifs_ioctl,
1200         .copy_file_range = cifs_copy_file_range,
1201         .clone_file_range = cifs_clone_file_range,
1202         .setlease = cifs_setlease,
1203         .fallocate = cifs_fallocate,
1204 };
1205
1206 const struct file_operations cifs_file_strict_nobrl_ops = {
1207         .read_iter = cifs_strict_readv,
1208         .write_iter = cifs_strict_writev,
1209         .open = cifs_open,
1210         .release = cifs_close,
1211         .fsync = cifs_strict_fsync,
1212         .flush = cifs_flush,
1213         .mmap = cifs_file_strict_mmap,
1214         .splice_read = generic_file_splice_read,
1215         .splice_write = iter_file_splice_write,
1216         .llseek = cifs_llseek,
1217         .unlocked_ioctl = cifs_ioctl,
1218         .copy_file_range = cifs_copy_file_range,
1219         .clone_file_range = cifs_clone_file_range,
1220         .setlease = cifs_setlease,
1221         .fallocate = cifs_fallocate,
1222 };
1223
1224 const struct file_operations cifs_file_direct_nobrl_ops = {
1225         /* BB reevaluate whether they can be done with directio, no cache */
1226         .read_iter = cifs_user_readv,
1227         .write_iter = cifs_user_writev,
1228         .open = cifs_open,
1229         .release = cifs_close,
1230         .fsync = cifs_fsync,
1231         .flush = cifs_flush,
1232         .mmap = cifs_file_mmap,
1233         .splice_read = generic_file_splice_read,
1234         .splice_write = iter_file_splice_write,
1235         .unlocked_ioctl  = cifs_ioctl,
1236         .copy_file_range = cifs_copy_file_range,
1237         .clone_file_range = cifs_clone_file_range,
1238         .llseek = cifs_llseek,
1239         .setlease = cifs_setlease,
1240         .fallocate = cifs_fallocate,
1241 };
1242
1243 const struct file_operations cifs_dir_ops = {
1244         .iterate_shared = cifs_readdir,
1245         .release = cifs_closedir,
1246         .read    = generic_read_dir,
1247         .unlocked_ioctl  = cifs_ioctl,
1248         .copy_file_range = cifs_copy_file_range,
1249         .clone_file_range = cifs_clone_file_range,
1250         .llseek = generic_file_llseek,
1251         .fsync = cifs_dir_fsync,
1252 };
1253
1254 static void
1255 cifs_init_once(void *inode)
1256 {
1257         struct cifsInodeInfo *cifsi = inode;
1258
1259         inode_init_once(&cifsi->vfs_inode);
1260         init_rwsem(&cifsi->lock_sem);
1261 }
1262
1263 static int __init
1264 cifs_init_inodecache(void)
1265 {
1266         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1267                                               sizeof(struct cifsInodeInfo),
1268                                               0, (SLAB_RECLAIM_ACCOUNT|
1269                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1270                                               cifs_init_once);
1271         if (cifs_inode_cachep == NULL)
1272                 return -ENOMEM;
1273
1274         return 0;
1275 }
1276
1277 static void
1278 cifs_destroy_inodecache(void)
1279 {
1280         /*
1281          * Make sure all delayed rcu free inodes are flushed before we
1282          * destroy cache.
1283          */
1284         rcu_barrier();
1285         kmem_cache_destroy(cifs_inode_cachep);
1286 }
1287
1288 static int
1289 cifs_init_request_bufs(void)
1290 {
1291         /*
1292          * SMB2 maximum header size is bigger than CIFS one - no problems to
1293          * allocate some more bytes for CIFS.
1294          */
1295         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1296
1297         if (CIFSMaxBufSize < 8192) {
1298         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1299         Unicode path name has to fit in any SMB/CIFS path based frames */
1300                 CIFSMaxBufSize = 8192;
1301         } else if (CIFSMaxBufSize > 1024*127) {
1302                 CIFSMaxBufSize = 1024 * 127;
1303         } else {
1304                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1305         }
1306 /*
1307         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1308                  CIFSMaxBufSize, CIFSMaxBufSize);
1309 */
1310         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1311                                             CIFSMaxBufSize + max_hdr_size, 0,
1312                                             SLAB_HWCACHE_ALIGN, 0,
1313                                             CIFSMaxBufSize + max_hdr_size,
1314                                             NULL);
1315         if (cifs_req_cachep == NULL)
1316                 return -ENOMEM;
1317
1318         if (cifs_min_rcv < 1)
1319                 cifs_min_rcv = 1;
1320         else if (cifs_min_rcv > 64) {
1321                 cifs_min_rcv = 64;
1322                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1323         }
1324
1325         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1326                                                   cifs_req_cachep);
1327
1328         if (cifs_req_poolp == NULL) {
1329                 kmem_cache_destroy(cifs_req_cachep);
1330                 return -ENOMEM;
1331         }
1332         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1333         almost all handle based requests (but not write response, nor is it
1334         sufficient for path based requests).  A smaller size would have
1335         been more efficient (compacting multiple slab items on one 4k page)
1336         for the case in which debug was on, but this larger size allows
1337         more SMBs to use small buffer alloc and is still much more
1338         efficient to alloc 1 per page off the slab compared to 17K (5page)
1339         alloc of large cifs buffers even when page debugging is on */
1340         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1341                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1342                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1343         if (cifs_sm_req_cachep == NULL) {
1344                 mempool_destroy(cifs_req_poolp);
1345                 kmem_cache_destroy(cifs_req_cachep);
1346                 return -ENOMEM;
1347         }
1348
1349         if (cifs_min_small < 2)
1350                 cifs_min_small = 2;
1351         else if (cifs_min_small > 256) {
1352                 cifs_min_small = 256;
1353                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1354         }
1355
1356         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1357                                                      cifs_sm_req_cachep);
1358
1359         if (cifs_sm_req_poolp == NULL) {
1360                 mempool_destroy(cifs_req_poolp);
1361                 kmem_cache_destroy(cifs_req_cachep);
1362                 kmem_cache_destroy(cifs_sm_req_cachep);
1363                 return -ENOMEM;
1364         }
1365
1366         return 0;
1367 }
1368
1369 static void
1370 cifs_destroy_request_bufs(void)
1371 {
1372         mempool_destroy(cifs_req_poolp);
1373         kmem_cache_destroy(cifs_req_cachep);
1374         mempool_destroy(cifs_sm_req_poolp);
1375         kmem_cache_destroy(cifs_sm_req_cachep);
1376 }
1377
1378 static int
1379 cifs_init_mids(void)
1380 {
1381         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1382                                             sizeof(struct mid_q_entry), 0,
1383                                             SLAB_HWCACHE_ALIGN, NULL);
1384         if (cifs_mid_cachep == NULL)
1385                 return -ENOMEM;
1386
1387         /* 3 is a reasonable minimum number of simultaneous operations */
1388         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1389         if (cifs_mid_poolp == NULL) {
1390                 kmem_cache_destroy(cifs_mid_cachep);
1391                 return -ENOMEM;
1392         }
1393
1394         return 0;
1395 }
1396
1397 static void
1398 cifs_destroy_mids(void)
1399 {
1400         mempool_destroy(cifs_mid_poolp);
1401         kmem_cache_destroy(cifs_mid_cachep);
1402 }
1403
1404 static int __init
1405 init_cifs(void)
1406 {
1407         int rc = 0;
1408         cifs_proc_init();
1409         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1410 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1411         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1412         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1413 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1414 /*
1415  *  Initialize Global counters
1416  */
1417         atomic_set(&sesInfoAllocCount, 0);
1418         atomic_set(&tconInfoAllocCount, 0);
1419         atomic_set(&tcpSesAllocCount, 0);
1420         atomic_set(&tcpSesReconnectCount, 0);
1421         atomic_set(&tconInfoReconnectCount, 0);
1422
1423         atomic_set(&bufAllocCount, 0);
1424         atomic_set(&smBufAllocCount, 0);
1425 #ifdef CONFIG_CIFS_STATS2
1426         atomic_set(&totBufAllocCount, 0);
1427         atomic_set(&totSmBufAllocCount, 0);
1428 #endif /* CONFIG_CIFS_STATS2 */
1429
1430         atomic_set(&midCount, 0);
1431         GlobalCurrentXid = 0;
1432         GlobalTotalActiveXid = 0;
1433         GlobalMaxActiveXid = 0;
1434         spin_lock_init(&cifs_tcp_ses_lock);
1435         spin_lock_init(&GlobalMid_Lock);
1436
1437         cifs_lock_secret = get_random_u32();
1438
1439         if (cifs_max_pending < 2) {
1440                 cifs_max_pending = 2;
1441                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1442         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1443                 cifs_max_pending = CIFS_MAX_REQ;
1444                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1445                          CIFS_MAX_REQ);
1446         }
1447
1448         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1449         if (!cifsiod_wq) {
1450                 rc = -ENOMEM;
1451                 goto out_clean_proc;
1452         }
1453
1454         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1455                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1456         if (!cifsoplockd_wq) {
1457                 rc = -ENOMEM;
1458                 goto out_destroy_cifsiod_wq;
1459         }
1460
1461         rc = cifs_fscache_register();
1462         if (rc)
1463                 goto out_destroy_cifsoplockd_wq;
1464
1465         rc = cifs_init_inodecache();
1466         if (rc)
1467                 goto out_unreg_fscache;
1468
1469         rc = cifs_init_mids();
1470         if (rc)
1471                 goto out_destroy_inodecache;
1472
1473         rc = cifs_init_request_bufs();
1474         if (rc)
1475                 goto out_destroy_mids;
1476
1477 #ifdef CONFIG_CIFS_UPCALL
1478         rc = init_cifs_spnego();
1479         if (rc)
1480                 goto out_destroy_request_bufs;
1481 #endif /* CONFIG_CIFS_UPCALL */
1482
1483 #ifdef CONFIG_CIFS_ACL
1484         rc = init_cifs_idmap();
1485         if (rc)
1486                 goto out_register_key_type;
1487 #endif /* CONFIG_CIFS_ACL */
1488
1489         rc = register_filesystem(&cifs_fs_type);
1490         if (rc)
1491                 goto out_init_cifs_idmap;
1492
1493         rc = register_filesystem(&smb3_fs_type);
1494         if (rc) {
1495                 unregister_filesystem(&cifs_fs_type);
1496                 goto out_init_cifs_idmap;
1497         }
1498
1499         return 0;
1500
1501 out_init_cifs_idmap:
1502 #ifdef CONFIG_CIFS_ACL
1503         exit_cifs_idmap();
1504 out_register_key_type:
1505 #endif
1506 #ifdef CONFIG_CIFS_UPCALL
1507         exit_cifs_spnego();
1508 out_destroy_request_bufs:
1509 #endif
1510         cifs_destroy_request_bufs();
1511 out_destroy_mids:
1512         cifs_destroy_mids();
1513 out_destroy_inodecache:
1514         cifs_destroy_inodecache();
1515 out_unreg_fscache:
1516         cifs_fscache_unregister();
1517 out_destroy_cifsoplockd_wq:
1518         destroy_workqueue(cifsoplockd_wq);
1519 out_destroy_cifsiod_wq:
1520         destroy_workqueue(cifsiod_wq);
1521 out_clean_proc:
1522         cifs_proc_clean();
1523         return rc;
1524 }
1525
1526 static void __exit
1527 exit_cifs(void)
1528 {
1529         cifs_dbg(NOISY, "exit_smb3\n");
1530         unregister_filesystem(&cifs_fs_type);
1531         unregister_filesystem(&smb3_fs_type);
1532         cifs_dfs_release_automount_timer();
1533 #ifdef CONFIG_CIFS_ACL
1534         exit_cifs_idmap();
1535 #endif
1536 #ifdef CONFIG_CIFS_UPCALL
1537         exit_cifs_spnego();
1538 #endif
1539         cifs_destroy_request_bufs();
1540         cifs_destroy_mids();
1541         cifs_destroy_inodecache();
1542         cifs_fscache_unregister();
1543         destroy_workqueue(cifsoplockd_wq);
1544         destroy_workqueue(cifsiod_wq);
1545         cifs_proc_clean();
1546 }
1547
1548 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1549 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1550 MODULE_DESCRIPTION
1551     ("VFS to access servers complying with the SNIA CIFS Specification "
1552      "e.g. Samba and Windows");
1553 MODULE_VERSION(CIFS_VERSION);
1554 MODULE_SOFTDEP("pre: arc4");
1555 MODULE_SOFTDEP("pre: des");
1556 MODULE_SOFTDEP("pre: ecb");
1557 MODULE_SOFTDEP("pre: hmac");
1558 MODULE_SOFTDEP("pre: md4");
1559 MODULE_SOFTDEP("pre: md5");
1560 MODULE_SOFTDEP("pre: nls");
1561 MODULE_SOFTDEP("pre: aes");
1562 MODULE_SOFTDEP("pre: cmac");
1563 MODULE_SOFTDEP("pre: sha256");
1564 MODULE_SOFTDEP("pre: sha512");
1565 MODULE_SOFTDEP("pre: aead2");
1566 MODULE_SOFTDEP("pre: ccm");
1567 module_init(init_cifs)
1568 module_exit(exit_cifs)