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