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 rc;
 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         return root;
 750 out:
 751         cifs_cleanup_volume_info(volume_info);
 752         return root;
 753
 754 out_free:
 755         kfree(cifs_sb->prepath);
 756         kfree(cifs_sb->mountdata);
 757         kfree(cifs_sb);
 758 out_nls:
 759         unload_nls(volume_info->local_nls);
 760         goto out;
 761 }
 762
 763 static ssize_t
 764 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 765 {
 766         ssize_t rc;
 767         struct inode *inode = file_inode(iocb->ki_filp);
 768
 769         if (iocb->ki_flags & IOCB_DIRECT)
 770                 return cifs_user_readv(iocb, iter);
 771
 772         rc = cifs_revalidate_mapping(inode);
 773         if (rc)
 774                 return rc;
 775
 776         return generic_file_read_iter(iocb, iter);
 777 }
 778
 779 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 780 {
 781         struct inode *inode = file_inode(iocb->ki_filp);
 782         struct cifsInodeInfo *cinode = CIFS_I(inode);
 783         ssize_t written;
 784         int rc;
 785
 786         if (iocb->ki_filp->f_flags & O_DIRECT) {
 787                 written = cifs_user_writev(iocb, from);
 788                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 789                         cifs_zap_mapping(inode);
 790                         cifs_dbg(FYI,
 791                                  "Set no oplock for inode=%p after a write operation\n",
 792                                  inode);
 793                         cinode->oplock = 0;
 794                 }
 795                 return written;
 796         }
 797
 798         written = cifs_get_writer(cinode);
 799         if (written)
 800                 return written;
 801
 802         written = generic_file_write_iter(iocb, from);
 803
 804         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 805                 goto out;
 806
 807         rc = filemap_fdatawrite(inode->i_mapping);
 808         if (rc)
 809                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 810                          rc, inode);
 811
 812 out:
 813         cifs_put_writer(cinode);
 814         return written;
 815 }
 816
 817 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 818 {
 819         /*
 820          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 821          * the cached file length
 822          */
 823         if (whence != SEEK_SET && whence != SEEK_CUR) {
 824                 int rc;
 825                 struct inode *inode = file_inode(file);
 826
 827                 /*
 828                  * We need to be sure that all dirty pages are written and the
 829                  * server has the newest file length.
 830                  */
 831                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 832                     inode->i_mapping->nrpages != 0) {
 833                         rc = filemap_fdatawait(inode->i_mapping);
 834                         if (rc) {
 835                                 mapping_set_error(inode->i_mapping, rc);
 836                                 return rc;
 837                         }
 838                 }
 839                 /*
 840                  * Some applications poll for the file length in this strange
 841                  * way so we must seek to end on non-oplocked files by
 842                  * setting the revalidate time to zero.
 843                  */
 844                 CIFS_I(inode)->time = 0;
 845
 846                 rc = cifs_revalidate_file_attr(file);
 847                 if (rc < 0)
 848                         return (loff_t)rc;
 849         }
 850         return generic_file_llseek(file, offset, whence);
 851 }
 852
 853 static int
 854 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 855 {
 856         /*
 857          * Note that this is called by vfs setlease with i_lock held to
 858          * protect *lease from going away.
 859          */
 860         struct inode *inode = file_inode(file);
 861         struct cifsFileInfo *cfile = file->private_data;
 862
 863         if (!(S_ISREG(inode->i_mode)))
 864                 return -EINVAL;
 865
 866         /* Check if file is oplocked if this is request for new lease */
 867         if (arg == F_UNLCK ||
 868             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 869             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 870                 return generic_setlease(file, arg, lease, priv);
 871         else if (tlink_tcon(cfile->tlink)->local_lease &&
 872                  !CIFS_CACHE_READ(CIFS_I(inode)))
 873                 /*
 874                  * If the server claims to support oplock on this file, then we
 875                  * still need to check oplock even if the local_lease mount
 876                  * option is set, but there are servers which do not support
 877                  * oplock for which this mount option may be useful if the user
 878                  * knows that the file won't be changed on the server by anyone
 879                  * else.
 880                  */
 881                 return generic_setlease(file, arg, lease, priv);
 882         else
 883                 return -EAGAIN;
 884 }
 885
 886 struct file_system_type cifs_fs_type = {
 887         .owner = THIS_MODULE,
 888         .name = "cifs",
 889         .mount = cifs_do_mount,
 890         .kill_sb = cifs_kill_sb,
 891         /*  .fs_flags */
 892 };
 893 MODULE_ALIAS_FS("cifs");
 894 const struct inode_operations cifs_dir_inode_ops = {
 895         .create = cifs_create,
 896         .atomic_open = cifs_atomic_open,
 897         .lookup = cifs_lookup,
 898         .getattr = cifs_getattr,
 899         .unlink = cifs_unlink,
 900         .link = cifs_hardlink,
 901         .mkdir = cifs_mkdir,
 902         .rmdir = cifs_rmdir,
 903         .rename = cifs_rename2,
 904         .permission = cifs_permission,
 905         .setattr = cifs_setattr,
 906         .symlink = cifs_symlink,
 907         .mknod   = cifs_mknod,
 908         .listxattr = cifs_listxattr,
 909 };
 910
 911 const struct inode_operations cifs_file_inode_ops = {
 912         .setattr = cifs_setattr,
 913         .getattr = cifs_getattr,
 914         .permission = cifs_permission,
 915         .listxattr = cifs_listxattr,
 916 };
 917
 918 const struct inode_operations cifs_symlink_inode_ops = {
 919         .readlink = generic_readlink,
 920         .get_link = cifs_get_link,
 921         .permission = cifs_permission,
 922         .listxattr = cifs_listxattr,
 923 };
 924
 925 static int cifs_clone_file_range(struct file *src_file, loff_t off,
 926                 struct file *dst_file, loff_t destoff, u64 len)
 927 {
 928         struct inode *src_inode = file_inode(src_file);
 929         struct inode *target_inode = file_inode(dst_file);
 930         struct cifsFileInfo *smb_file_src = src_file->private_data;
 931         struct cifsFileInfo *smb_file_target;
 932         struct cifs_tcon *target_tcon;
 933         unsigned int xid;
 934         int rc;
 935
 936         cifs_dbg(FYI, "clone range\n");
 937
 938         xid = get_xid();
 939
 940         if (!src_file->private_data || !dst_file->private_data) {
 941                 rc = -EBADF;
 942                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
 943                 goto out;
 944         }
 945
 946         smb_file_target = dst_file->private_data;
 947         target_tcon = tlink_tcon(smb_file_target->tlink);
 948
 949         /*
 950          * Note: cifs case is easier than btrfs since server responsible for
 951          * checks for proper open modes and file type and if it wants
 952          * server could even support copy of range where source = target
 953          */
 954         lock_two_nondirectories(target_inode, src_inode);
 955
 956         if (len == 0)
 957                 len = src_inode->i_size - off;
 958
 959         cifs_dbg(FYI, "about to flush pages\n");
 960         /* should we flush first and last page first */
 961         truncate_inode_pages_range(&target_inode->i_data, destoff,
 962                                    PAGE_ALIGN(destoff + len)-1);
 963
 964         if (target_tcon->ses->server->ops->duplicate_extents)
 965                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
 966                         smb_file_src, smb_file_target, off, len, destoff);
 967         else
 968                 rc = -EOPNOTSUPP;
 969
 970         /* force revalidate of size and timestamps of target file now
 971            that target is updated on the server */
 972         CIFS_I(target_inode)->time = 0;
 973         /* although unlocking in the reverse order from locking is not
 974            strictly necessary here it is a little cleaner to be consistent */
 975         unlock_two_nondirectories(src_inode, target_inode);
 976 out:
 977         free_xid(xid);
 978         return rc;
 979 }
 980
 981 const struct file_operations cifs_file_ops = {
 982         .read_iter = cifs_loose_read_iter,
 983         .write_iter = cifs_file_write_iter,
 984         .open = cifs_open,
 985         .release = cifs_close,
 986         .lock = cifs_lock,
 987         .fsync = cifs_fsync,
 988         .flush = cifs_flush,
 989         .mmap  = cifs_file_mmap,
 990         .splice_read = generic_file_splice_read,
 991         .llseek = cifs_llseek,
 992         .unlocked_ioctl = cifs_ioctl,
 993         .clone_file_range = cifs_clone_file_range,
 994         .setlease = cifs_setlease,
 995         .fallocate = cifs_fallocate,
 996 };
 997
 998 const struct file_operations cifs_file_strict_ops = {
 999         .read_iter = cifs_strict_readv,
1000         .write_iter = cifs_strict_writev,
1001         .open = cifs_open,
1002         .release = cifs_close,
1003         .lock = cifs_lock,
1004         .fsync = cifs_strict_fsync,
1005         .flush = cifs_flush,
1006         .mmap = cifs_file_strict_mmap,
1007         .splice_read = generic_file_splice_read,
1008         .llseek = cifs_llseek,
1009         .unlocked_ioctl = cifs_ioctl,
1010         .clone_file_range = cifs_clone_file_range,
1011         .setlease = cifs_setlease,
1012         .fallocate = cifs_fallocate,
1013 };
1014
1015 const struct file_operations cifs_file_direct_ops = {
1016         /* BB reevaluate whether they can be done with directio, no cache */
1017         .read_iter = cifs_user_readv,
1018         .write_iter = cifs_user_writev,
1019         .open = cifs_open,
1020         .release = cifs_close,
1021         .lock = cifs_lock,
1022         .fsync = cifs_fsync,
1023         .flush = cifs_flush,
1024         .mmap = cifs_file_mmap,
1025         .splice_read = generic_file_splice_read,
1026         .unlocked_ioctl  = cifs_ioctl,
1027         .clone_file_range = cifs_clone_file_range,
1028         .llseek = cifs_llseek,
1029         .setlease = cifs_setlease,
1030         .fallocate = cifs_fallocate,
1031 };
1032
1033 const struct file_operations cifs_file_nobrl_ops = {
1034         .read_iter = cifs_loose_read_iter,
1035         .write_iter = cifs_file_write_iter,
1036         .open = cifs_open,
1037         .release = cifs_close,
1038         .fsync = cifs_fsync,
1039         .flush = cifs_flush,
1040         .mmap  = cifs_file_mmap,
1041         .splice_read = generic_file_splice_read,
1042         .llseek = cifs_llseek,
1043         .unlocked_ioctl = cifs_ioctl,
1044         .clone_file_range = cifs_clone_file_range,
1045         .setlease = cifs_setlease,
1046         .fallocate = cifs_fallocate,
1047 };
1048
1049 const struct file_operations cifs_file_strict_nobrl_ops = {
1050         .read_iter = cifs_strict_readv,
1051         .write_iter = cifs_strict_writev,
1052         .open = cifs_open,
1053         .release = cifs_close,
1054         .fsync = cifs_strict_fsync,
1055         .flush = cifs_flush,
1056         .mmap = cifs_file_strict_mmap,
1057         .splice_read = generic_file_splice_read,
1058         .llseek = cifs_llseek,
1059         .unlocked_ioctl = cifs_ioctl,
1060         .clone_file_range = cifs_clone_file_range,
1061         .setlease = cifs_setlease,
1062         .fallocate = cifs_fallocate,
1063 };
1064
1065 const struct file_operations cifs_file_direct_nobrl_ops = {
1066         /* BB reevaluate whether they can be done with directio, no cache */
1067         .read_iter = cifs_user_readv,
1068         .write_iter = cifs_user_writev,
1069         .open = cifs_open,
1070         .release = cifs_close,
1071         .fsync = cifs_fsync,
1072         .flush = cifs_flush,
1073         .mmap = cifs_file_mmap,
1074         .splice_read = generic_file_splice_read,
1075         .unlocked_ioctl  = cifs_ioctl,
1076         .clone_file_range = cifs_clone_file_range,
1077         .llseek = cifs_llseek,
1078         .setlease = cifs_setlease,
1079         .fallocate = cifs_fallocate,
1080 };
1081
1082 const struct file_operations cifs_dir_ops = {
1083         .iterate_shared = cifs_readdir,
1084         .release = cifs_closedir,
1085         .read    = generic_read_dir,
1086         .unlocked_ioctl  = cifs_ioctl,
1087         .clone_file_range = cifs_clone_file_range,
1088         .llseek = generic_file_llseek,
1089 };
1090
1091 static void
1092 cifs_init_once(void *inode)
1093 {
1094         struct cifsInodeInfo *cifsi = inode;
1095
1096         inode_init_once(&cifsi->vfs_inode);
1097         init_rwsem(&cifsi->lock_sem);
1098 }
1099
1100 static int __init
1101 cifs_init_inodecache(void)
1102 {
1103         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1104                                               sizeof(struct cifsInodeInfo),
1105                                               0, (SLAB_RECLAIM_ACCOUNT|
1106                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1107                                               cifs_init_once);
1108         if (cifs_inode_cachep == NULL)
1109                 return -ENOMEM;
1110
1111         return 0;
1112 }
1113
1114 static void
1115 cifs_destroy_inodecache(void)
1116 {
1117         /*
1118          * Make sure all delayed rcu free inodes are flushed before we
1119          * destroy cache.
1120          */
1121         rcu_barrier();
1122         kmem_cache_destroy(cifs_inode_cachep);
1123 }
1124
1125 static int
1126 cifs_init_request_bufs(void)
1127 {
1128         size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1129 #ifdef CONFIG_CIFS_SMB2
1130         /*
1131          * SMB2 maximum header size is bigger than CIFS one - no problems to
1132          * allocate some more bytes for CIFS.
1133          */
1134         max_hdr_size = MAX_SMB2_HDR_SIZE;
1135 #endif
1136         if (CIFSMaxBufSize < 8192) {
1137         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1138         Unicode path name has to fit in any SMB/CIFS path based frames */
1139                 CIFSMaxBufSize = 8192;
1140         } else if (CIFSMaxBufSize > 1024*127) {
1141                 CIFSMaxBufSize = 1024 * 127;
1142         } else {
1143                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1144         }
1145 /*
1146         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1147                  CIFSMaxBufSize, CIFSMaxBufSize);
1148 */
1149         cifs_req_cachep = kmem_cache_create("cifs_request",
1150                                             CIFSMaxBufSize + max_hdr_size, 0,
1151                                             SLAB_HWCACHE_ALIGN, NULL);
1152         if (cifs_req_cachep == NULL)
1153                 return -ENOMEM;
1154
1155         if (cifs_min_rcv < 1)
1156                 cifs_min_rcv = 1;
1157         else if (cifs_min_rcv > 64) {
1158                 cifs_min_rcv = 64;
1159                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1160         }
1161
1162         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1163                                                   cifs_req_cachep);
1164
1165         if (cifs_req_poolp == NULL) {
1166                 kmem_cache_destroy(cifs_req_cachep);
1167                 return -ENOMEM;
1168         }
1169         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1170         almost all handle based requests (but not write response, nor is it
1171         sufficient for path based requests).  A smaller size would have
1172         been more efficient (compacting multiple slab items on one 4k page)
1173         for the case in which debug was on, but this larger size allows
1174         more SMBs to use small buffer alloc and is still much more
1175         efficient to alloc 1 per page off the slab compared to 17K (5page)
1176         alloc of large cifs buffers even when page debugging is on */
1177         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1178                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1179                         NULL);
1180         if (cifs_sm_req_cachep == NULL) {
1181                 mempool_destroy(cifs_req_poolp);
1182                 kmem_cache_destroy(cifs_req_cachep);
1183                 return -ENOMEM;
1184         }
1185
1186         if (cifs_min_small < 2)
1187                 cifs_min_small = 2;
1188         else if (cifs_min_small > 256) {
1189                 cifs_min_small = 256;
1190                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1191         }
1192
1193         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1194                                                      cifs_sm_req_cachep);
1195
1196         if (cifs_sm_req_poolp == NULL) {
1197                 mempool_destroy(cifs_req_poolp);
1198                 kmem_cache_destroy(cifs_req_cachep);
1199                 kmem_cache_destroy(cifs_sm_req_cachep);
1200                 return -ENOMEM;
1201         }
1202
1203         return 0;
1204 }
1205
1206 static void
1207 cifs_destroy_request_bufs(void)
1208 {
1209         mempool_destroy(cifs_req_poolp);
1210         kmem_cache_destroy(cifs_req_cachep);
1211         mempool_destroy(cifs_sm_req_poolp);
1212         kmem_cache_destroy(cifs_sm_req_cachep);
1213 }
1214
1215 static int
1216 cifs_init_mids(void)
1217 {
1218         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1219                                             sizeof(struct mid_q_entry), 0,
1220                                             SLAB_HWCACHE_ALIGN, NULL);
1221         if (cifs_mid_cachep == NULL)
1222                 return -ENOMEM;
1223
1224         /* 3 is a reasonable minimum number of simultaneous operations */
1225         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1226         if (cifs_mid_poolp == NULL) {
1227                 kmem_cache_destroy(cifs_mid_cachep);
1228                 return -ENOMEM;
1229         }
1230
1231         return 0;
1232 }
1233
1234 static void
1235 cifs_destroy_mids(void)
1236 {
1237         mempool_destroy(cifs_mid_poolp);
1238         kmem_cache_destroy(cifs_mid_cachep);
1239 }
1240
1241 static int __init
1242 init_cifs(void)
1243 {
1244         int rc = 0;
1245         cifs_proc_init();
1246         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1247 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1248         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1249         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1250 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1251 /*
1252  *  Initialize Global counters
1253  */
1254         atomic_set(&sesInfoAllocCount, 0);
1255         atomic_set(&tconInfoAllocCount, 0);
1256         atomic_set(&tcpSesAllocCount, 0);
1257         atomic_set(&tcpSesReconnectCount, 0);
1258         atomic_set(&tconInfoReconnectCount, 0);
1259
1260         atomic_set(&bufAllocCount, 0);
1261         atomic_set(&smBufAllocCount, 0);
1262 #ifdef CONFIG_CIFS_STATS2
1263         atomic_set(&totBufAllocCount, 0);
1264         atomic_set(&totSmBufAllocCount, 0);
1265 #endif /* CONFIG_CIFS_STATS2 */
1266
1267         atomic_set(&midCount, 0);
1268         GlobalCurrentXid = 0;
1269         GlobalTotalActiveXid = 0;
1270         GlobalMaxActiveXid = 0;
1271         spin_lock_init(&cifs_tcp_ses_lock);
1272         spin_lock_init(&GlobalMid_Lock);
1273
1274         get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
1275
1276         if (cifs_max_pending < 2) {
1277                 cifs_max_pending = 2;
1278                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1279         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1280                 cifs_max_pending = CIFS_MAX_REQ;
1281                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1282                          CIFS_MAX_REQ);
1283         }
1284
1285         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1286         if (!cifsiod_wq) {
1287                 rc = -ENOMEM;
1288                 goto out_clean_proc;
1289         }
1290
1291         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1292                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1293         if (!cifsoplockd_wq) {
1294                 rc = -ENOMEM;
1295                 goto out_destroy_cifsiod_wq;
1296         }
1297
1298         rc = cifs_fscache_register();
1299         if (rc)
1300                 goto out_destroy_cifsoplockd_wq;
1301
1302         rc = cifs_init_inodecache();
1303         if (rc)
1304                 goto out_unreg_fscache;
1305
1306         rc = cifs_init_mids();
1307         if (rc)
1308                 goto out_destroy_inodecache;
1309
1310         rc = cifs_init_request_bufs();
1311         if (rc)
1312                 goto out_destroy_mids;
1313
1314 #ifdef CONFIG_CIFS_UPCALL
1315         rc = init_cifs_spnego();
1316         if (rc)
1317                 goto out_destroy_request_bufs;
1318 #endif /* CONFIG_CIFS_UPCALL */
1319
1320 #ifdef CONFIG_CIFS_ACL
1321         rc = init_cifs_idmap();
1322         if (rc)
1323                 goto out_register_key_type;
1324 #endif /* CONFIG_CIFS_ACL */
1325
1326         rc = register_filesystem(&cifs_fs_type);
1327         if (rc)
1328                 goto out_init_cifs_idmap;
1329
1330         return 0;
1331
1332 out_init_cifs_idmap:
1333 #ifdef CONFIG_CIFS_ACL
1334         exit_cifs_idmap();
1335 out_register_key_type:
1336 #endif
1337 #ifdef CONFIG_CIFS_UPCALL
1338         exit_cifs_spnego();
1339 out_destroy_request_bufs:
1340 #endif
1341         cifs_destroy_request_bufs();
1342 out_destroy_mids:
1343         cifs_destroy_mids();
1344 out_destroy_inodecache:
1345         cifs_destroy_inodecache();
1346 out_unreg_fscache:
1347         cifs_fscache_unregister();
1348 out_destroy_cifsoplockd_wq:
1349         destroy_workqueue(cifsoplockd_wq);
1350 out_destroy_cifsiod_wq:
1351         destroy_workqueue(cifsiod_wq);
1352 out_clean_proc:
1353         cifs_proc_clean();
1354         return rc;
1355 }
1356
1357 static void __exit
1358 exit_cifs(void)
1359 {
1360         cifs_dbg(NOISY, "exit_cifs\n");
1361         unregister_filesystem(&cifs_fs_type);
1362         cifs_dfs_release_automount_timer();
1363 #ifdef CONFIG_CIFS_ACL
1364         exit_cifs_idmap();
1365 #endif
1366 #ifdef CONFIG_CIFS_UPCALL
1367         exit_cifs_spnego();
1368 #endif
1369         cifs_destroy_request_bufs();
1370         cifs_destroy_mids();
1371         cifs_destroy_inodecache();
1372         cifs_fscache_unregister();
1373         destroy_workqueue(cifsoplockd_wq);
1374         destroy_workqueue(cifsiod_wq);
1375         cifs_proc_clean();
1376 }
1377
1378 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1379 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1380 MODULE_DESCRIPTION
1381     ("VFS to access servers complying with the SNIA CIFS Specification "
1382      "e.g. Samba and Windows");
1383 MODULE_VERSION(CIFS_VERSION);
1384 module_init(init_cifs)
1385 module_exit(exit_cifs)