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