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