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