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