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