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