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