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