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