fs/cifs/cifsfs.c

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