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