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