fs/cifs/cifsfs.c

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