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