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         rc = -EOPNOTSUPP;
1108         if (!target_tcon->ses->server->ops->copychunk_range)
1109                 goto out;
1110
1111         /*
1112          * Note: cifs case is easier than btrfs since server responsible for
1113          * checks for proper open modes and file type and if it wants
1114          * server could even support copy of range where source = target
1115          */
1116         lock_two_nondirectories(target_inode, src_inode);
1117
1118         cifs_dbg(FYI, "about to flush pages\n");
1119         /* should we flush first and last page first */
1120         truncate_inode_pages(&target_inode->i_data, 0);
1121
1122         rc = file_modified(dst_file);
1123         if (!rc)
1124                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1125                         smb_file_src, smb_file_target, off, len, destoff);
1126
1127         file_accessed(src_file);
1128
1129         /* force revalidate of size and timestamps of target file now
1130          * that target is updated on the server
1131          */
1132         CIFS_I(target_inode)->time = 0;
1133         /* although unlocking in the reverse order from locking is not
1134          * strictly necessary here it is a little cleaner to be consistent
1135          */
1136         unlock_two_nondirectories(src_inode, target_inode);
1137
1138 out:
1139         return rc;
1140 }
1141
1142 /*
1143  * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1144  * is a dummy operation.
1145  */
1146 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1147 {
1148         cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1149                  file, datasync);
1150
1151         return 0;
1152 }
1153
1154 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1155                                 struct file *dst_file, loff_t destoff,
1156                                 size_t len, unsigned int flags)
1157 {
1158         unsigned int xid = get_xid();
1159         ssize_t rc;
1160
1161         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1162                                         len, flags);
1163         free_xid(xid);
1164
1165         if (rc == -EOPNOTSUPP || rc == -EXDEV)
1166                 rc = generic_copy_file_range(src_file, off, dst_file,
1167                                              destoff, len, flags);
1168         return rc;
1169 }
1170
1171 const struct file_operations cifs_file_ops = {
1172         .read_iter = cifs_loose_read_iter,
1173         .write_iter = cifs_file_write_iter,
1174         .open = cifs_open,
1175         .release = cifs_close,
1176         .lock = cifs_lock,
1177         .fsync = cifs_fsync,
1178         .flush = cifs_flush,
1179         .mmap  = cifs_file_mmap,
1180         .splice_read = generic_file_splice_read,
1181         .splice_write = iter_file_splice_write,
1182         .llseek = cifs_llseek,
1183         .unlocked_ioctl = cifs_ioctl,
1184         .copy_file_range = cifs_copy_file_range,
1185         .remap_file_range = cifs_remap_file_range,
1186         .setlease = cifs_setlease,
1187         .fallocate = cifs_fallocate,
1188 };
1189
1190 const struct file_operations cifs_file_strict_ops = {
1191         .read_iter = cifs_strict_readv,
1192         .write_iter = cifs_strict_writev,
1193         .open = cifs_open,
1194         .release = cifs_close,
1195         .lock = cifs_lock,
1196         .fsync = cifs_strict_fsync,
1197         .flush = cifs_flush,
1198         .mmap = cifs_file_strict_mmap,
1199         .splice_read = generic_file_splice_read,
1200         .splice_write = iter_file_splice_write,
1201         .llseek = cifs_llseek,
1202         .unlocked_ioctl = cifs_ioctl,
1203         .copy_file_range = cifs_copy_file_range,
1204         .remap_file_range = cifs_remap_file_range,
1205         .setlease = cifs_setlease,
1206         .fallocate = cifs_fallocate,
1207 };
1208
1209 const struct file_operations cifs_file_direct_ops = {
1210         .read_iter = cifs_direct_readv,
1211         .write_iter = cifs_direct_writev,
1212         .open = cifs_open,
1213         .release = cifs_close,
1214         .lock = cifs_lock,
1215         .fsync = cifs_fsync,
1216         .flush = cifs_flush,
1217         .mmap = cifs_file_mmap,
1218         .splice_read = generic_file_splice_read,
1219         .splice_write = iter_file_splice_write,
1220         .unlocked_ioctl  = cifs_ioctl,
1221         .copy_file_range = cifs_copy_file_range,
1222         .remap_file_range = cifs_remap_file_range,
1223         .llseek = cifs_llseek,
1224         .setlease = cifs_setlease,
1225         .fallocate = cifs_fallocate,
1226 };
1227
1228 const struct file_operations cifs_file_nobrl_ops = {
1229         .read_iter = cifs_loose_read_iter,
1230         .write_iter = cifs_file_write_iter,
1231         .open = cifs_open,
1232         .release = cifs_close,
1233         .fsync = cifs_fsync,
1234         .flush = cifs_flush,
1235         .mmap  = cifs_file_mmap,
1236         .splice_read = generic_file_splice_read,
1237         .splice_write = iter_file_splice_write,
1238         .llseek = cifs_llseek,
1239         .unlocked_ioctl = cifs_ioctl,
1240         .copy_file_range = cifs_copy_file_range,
1241         .remap_file_range = cifs_remap_file_range,
1242         .setlease = cifs_setlease,
1243         .fallocate = cifs_fallocate,
1244 };
1245
1246 const struct file_operations cifs_file_strict_nobrl_ops = {
1247         .read_iter = cifs_strict_readv,
1248         .write_iter = cifs_strict_writev,
1249         .open = cifs_open,
1250         .release = cifs_close,
1251         .fsync = cifs_strict_fsync,
1252         .flush = cifs_flush,
1253         .mmap = cifs_file_strict_mmap,
1254         .splice_read = generic_file_splice_read,
1255         .splice_write = iter_file_splice_write,
1256         .llseek = cifs_llseek,
1257         .unlocked_ioctl = cifs_ioctl,
1258         .copy_file_range = cifs_copy_file_range,
1259         .remap_file_range = cifs_remap_file_range,
1260         .setlease = cifs_setlease,
1261         .fallocate = cifs_fallocate,
1262 };
1263
1264 const struct file_operations cifs_file_direct_nobrl_ops = {
1265         .read_iter = cifs_direct_readv,
1266         .write_iter = cifs_direct_writev,
1267         .open = cifs_open,
1268         .release = cifs_close,
1269         .fsync = cifs_fsync,
1270         .flush = cifs_flush,
1271         .mmap = cifs_file_mmap,
1272         .splice_read = generic_file_splice_read,
1273         .splice_write = iter_file_splice_write,
1274         .unlocked_ioctl  = cifs_ioctl,
1275         .copy_file_range = cifs_copy_file_range,
1276         .remap_file_range = cifs_remap_file_range,
1277         .llseek = cifs_llseek,
1278         .setlease = cifs_setlease,
1279         .fallocate = cifs_fallocate,
1280 };
1281
1282 const struct file_operations cifs_dir_ops = {
1283         .iterate_shared = cifs_readdir,
1284         .release = cifs_closedir,
1285         .read    = generic_read_dir,
1286         .unlocked_ioctl  = cifs_ioctl,
1287         .copy_file_range = cifs_copy_file_range,
1288         .remap_file_range = cifs_remap_file_range,
1289         .llseek = generic_file_llseek,
1290         .fsync = cifs_dir_fsync,
1291 };
1292
1293 static void
1294 cifs_init_once(void *inode)
1295 {
1296         struct cifsInodeInfo *cifsi = inode;
1297
1298         inode_init_once(&cifsi->vfs_inode);
1299         init_rwsem(&cifsi->lock_sem);
1300 }
1301
1302 static int __init
1303 cifs_init_inodecache(void)
1304 {
1305         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1306                                               sizeof(struct cifsInodeInfo),
1307                                               0, (SLAB_RECLAIM_ACCOUNT|
1308                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1309                                               cifs_init_once);
1310         if (cifs_inode_cachep == NULL)
1311                 return -ENOMEM;
1312
1313         return 0;
1314 }
1315
1316 static void
1317 cifs_destroy_inodecache(void)
1318 {
1319         /*
1320          * Make sure all delayed rcu free inodes are flushed before we
1321          * destroy cache.
1322          */
1323         rcu_barrier();
1324         kmem_cache_destroy(cifs_inode_cachep);
1325 }
1326
1327 static int
1328 cifs_init_request_bufs(void)
1329 {
1330         /*
1331          * SMB2 maximum header size is bigger than CIFS one - no problems to
1332          * allocate some more bytes for CIFS.
1333          */
1334         size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1335
1336         if (CIFSMaxBufSize < 8192) {
1337         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1338         Unicode path name has to fit in any SMB/CIFS path based frames */
1339                 CIFSMaxBufSize = 8192;
1340         } else if (CIFSMaxBufSize > 1024*127) {
1341                 CIFSMaxBufSize = 1024 * 127;
1342         } else {
1343                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1344         }
1345 /*
1346         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1347                  CIFSMaxBufSize, CIFSMaxBufSize);
1348 */
1349         cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1350                                             CIFSMaxBufSize + max_hdr_size, 0,
1351                                             SLAB_HWCACHE_ALIGN, 0,
1352                                             CIFSMaxBufSize + max_hdr_size,
1353                                             NULL);
1354         if (cifs_req_cachep == NULL)
1355                 return -ENOMEM;
1356
1357         if (cifs_min_rcv < 1)
1358                 cifs_min_rcv = 1;
1359         else if (cifs_min_rcv > 64) {
1360                 cifs_min_rcv = 64;
1361                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1362         }
1363
1364         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1365                                                   cifs_req_cachep);
1366
1367         if (cifs_req_poolp == NULL) {
1368                 kmem_cache_destroy(cifs_req_cachep);
1369                 return -ENOMEM;
1370         }
1371         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1372         almost all handle based requests (but not write response, nor is it
1373         sufficient for path based requests).  A smaller size would have
1374         been more efficient (compacting multiple slab items on one 4k page)
1375         for the case in which debug was on, but this larger size allows
1376         more SMBs to use small buffer alloc and is still much more
1377         efficient to alloc 1 per page off the slab compared to 17K (5page)
1378         alloc of large cifs buffers even when page debugging is on */
1379         cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1380                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1381                         0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1382         if (cifs_sm_req_cachep == NULL) {
1383                 mempool_destroy(cifs_req_poolp);
1384                 kmem_cache_destroy(cifs_req_cachep);
1385                 return -ENOMEM;
1386         }
1387
1388         if (cifs_min_small < 2)
1389                 cifs_min_small = 2;
1390         else if (cifs_min_small > 256) {
1391                 cifs_min_small = 256;
1392                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1393         }
1394
1395         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1396                                                      cifs_sm_req_cachep);
1397
1398         if (cifs_sm_req_poolp == NULL) {
1399                 mempool_destroy(cifs_req_poolp);
1400                 kmem_cache_destroy(cifs_req_cachep);
1401                 kmem_cache_destroy(cifs_sm_req_cachep);
1402                 return -ENOMEM;
1403         }
1404
1405         return 0;
1406 }
1407
1408 static void
1409 cifs_destroy_request_bufs(void)
1410 {
1411         mempool_destroy(cifs_req_poolp);
1412         kmem_cache_destroy(cifs_req_cachep);
1413         mempool_destroy(cifs_sm_req_poolp);
1414         kmem_cache_destroy(cifs_sm_req_cachep);
1415 }
1416
1417 static int
1418 cifs_init_mids(void)
1419 {
1420         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1421                                             sizeof(struct mid_q_entry), 0,
1422                                             SLAB_HWCACHE_ALIGN, NULL);
1423         if (cifs_mid_cachep == NULL)
1424                 return -ENOMEM;
1425
1426         /* 3 is a reasonable minimum number of simultaneous operations */
1427         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1428         if (cifs_mid_poolp == NULL) {
1429                 kmem_cache_destroy(cifs_mid_cachep);
1430                 return -ENOMEM;
1431         }
1432
1433         return 0;
1434 }
1435
1436 static void
1437 cifs_destroy_mids(void)
1438 {
1439         mempool_destroy(cifs_mid_poolp);
1440         kmem_cache_destroy(cifs_mid_cachep);
1441 }
1442
1443 static int __init
1444 init_cifs(void)
1445 {
1446         int rc = 0;
1447         cifs_proc_init();
1448         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1449 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1450         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1451         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1452 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1453 /*
1454  *  Initialize Global counters
1455  */
1456         atomic_set(&sesInfoAllocCount, 0);
1457         atomic_set(&tconInfoAllocCount, 0);
1458         atomic_set(&tcpSesAllocCount, 0);
1459         atomic_set(&tcpSesReconnectCount, 0);
1460         atomic_set(&tconInfoReconnectCount, 0);
1461
1462         atomic_set(&bufAllocCount, 0);
1463         atomic_set(&smBufAllocCount, 0);
1464 #ifdef CONFIG_CIFS_STATS2
1465         atomic_set(&totBufAllocCount, 0);
1466         atomic_set(&totSmBufAllocCount, 0);
1467         if (slow_rsp_threshold < 1)
1468                 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1469         else if (slow_rsp_threshold > 32767)
1470                 cifs_dbg(VFS,
1471                        "slow response threshold set higher than recommended (0 to 32767)\n");
1472 #endif /* CONFIG_CIFS_STATS2 */
1473
1474         atomic_set(&midCount, 0);
1475         GlobalCurrentXid = 0;
1476         GlobalTotalActiveXid = 0;
1477         GlobalMaxActiveXid = 0;
1478         spin_lock_init(&cifs_tcp_ses_lock);
1479         spin_lock_init(&GlobalMid_Lock);
1480
1481         cifs_lock_secret = get_random_u32();
1482
1483         if (cifs_max_pending < 2) {
1484                 cifs_max_pending = 2;
1485                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1486         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1487                 cifs_max_pending = CIFS_MAX_REQ;
1488                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1489                          CIFS_MAX_REQ);
1490         }
1491
1492         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1493         if (!cifsiod_wq) {
1494                 rc = -ENOMEM;
1495                 goto out_clean_proc;
1496         }
1497
1498         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1499                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1500         if (!cifsoplockd_wq) {
1501                 rc = -ENOMEM;
1502                 goto out_destroy_cifsiod_wq;
1503         }
1504
1505         rc = cifs_fscache_register();
1506         if (rc)
1507                 goto out_destroy_cifsoplockd_wq;
1508
1509         rc = cifs_init_inodecache();
1510         if (rc)
1511                 goto out_unreg_fscache;
1512
1513         rc = cifs_init_mids();
1514         if (rc)
1515                 goto out_destroy_inodecache;
1516
1517         rc = cifs_init_request_bufs();
1518         if (rc)
1519                 goto out_destroy_mids;
1520
1521 #ifdef CONFIG_CIFS_DFS_UPCALL
1522         rc = dfs_cache_init();
1523         if (rc)
1524                 goto out_destroy_request_bufs;
1525 #endif /* CONFIG_CIFS_DFS_UPCALL */
1526 #ifdef CONFIG_CIFS_UPCALL
1527         rc = init_cifs_spnego();
1528         if (rc)
1529                 goto out_destroy_dfs_cache;
1530 #endif /* CONFIG_CIFS_UPCALL */
1531
1532         rc = init_cifs_idmap();
1533         if (rc)
1534                 goto out_register_key_type;
1535
1536         rc = register_filesystem(&cifs_fs_type);
1537         if (rc)
1538                 goto out_init_cifs_idmap;
1539
1540         rc = register_filesystem(&smb3_fs_type);
1541         if (rc) {
1542                 unregister_filesystem(&cifs_fs_type);
1543                 goto out_init_cifs_idmap;
1544         }
1545
1546         return 0;
1547
1548 out_init_cifs_idmap:
1549         exit_cifs_idmap();
1550 out_register_key_type:
1551 #ifdef CONFIG_CIFS_UPCALL
1552         exit_cifs_spnego();
1553 out_destroy_dfs_cache:
1554 #endif
1555 #ifdef CONFIG_CIFS_DFS_UPCALL
1556         dfs_cache_destroy();
1557 out_destroy_request_bufs:
1558 #endif
1559         cifs_destroy_request_bufs();
1560 out_destroy_mids:
1561         cifs_destroy_mids();
1562 out_destroy_inodecache:
1563         cifs_destroy_inodecache();
1564 out_unreg_fscache:
1565         cifs_fscache_unregister();
1566 out_destroy_cifsoplockd_wq:
1567         destroy_workqueue(cifsoplockd_wq);
1568 out_destroy_cifsiod_wq:
1569         destroy_workqueue(cifsiod_wq);
1570 out_clean_proc:
1571         cifs_proc_clean();
1572         return rc;
1573 }
1574
1575 static void __exit
1576 exit_cifs(void)
1577 {
1578         cifs_dbg(NOISY, "exit_smb3\n");
1579         unregister_filesystem(&cifs_fs_type);
1580         unregister_filesystem(&smb3_fs_type);
1581         cifs_dfs_release_automount_timer();
1582         exit_cifs_idmap();
1583 #ifdef CONFIG_CIFS_UPCALL
1584         exit_cifs_spnego();
1585 #endif
1586 #ifdef CONFIG_CIFS_DFS_UPCALL
1587         dfs_cache_destroy();
1588 #endif
1589         cifs_destroy_request_bufs();
1590         cifs_destroy_mids();
1591         cifs_destroy_inodecache();
1592         cifs_fscache_unregister();
1593         destroy_workqueue(cifsoplockd_wq);
1594         destroy_workqueue(cifsiod_wq);
1595         cifs_proc_clean();
1596 }
1597
1598 MODULE_AUTHOR("Steve French");
1599 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1600 MODULE_DESCRIPTION
1601         ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1602         "also older servers complying with the SNIA CIFS Specification)");
1603 MODULE_VERSION(CIFS_VERSION);
1604 MODULE_SOFTDEP("pre: des");
1605 MODULE_SOFTDEP("pre: ecb");
1606 MODULE_SOFTDEP("pre: hmac");
1607 MODULE_SOFTDEP("pre: md4");
1608 MODULE_SOFTDEP("pre: md5");
1609 MODULE_SOFTDEP("pre: nls");
1610 MODULE_SOFTDEP("pre: aes");
1611 MODULE_SOFTDEP("pre: cmac");
1612 MODULE_SOFTDEP("pre: sha256");
1613 MODULE_SOFTDEP("pre: sha512");
1614 MODULE_SOFTDEP("pre: aead2");
1615 MODULE_SOFTDEP("pre: ccm");
1616 MODULE_SOFTDEP("pre: gcm");
1617 module_init(init_cifs)
1618 module_exit(exit_cifs)