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