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