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_final(&inode->i_data);
 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         .permission = cifs_permission,
 854 #ifdef CONFIG_CIFS_XATTR
 855         .setxattr = cifs_setxattr,
 856         .getxattr = cifs_getxattr,
 857         .listxattr = cifs_listxattr,
 858         .removexattr = cifs_removexattr,
 859 #endif
 860 };
 861
 862 const struct inode_operations cifs_symlink_inode_ops = {
 863         .readlink = generic_readlink,
 864         .follow_link = cifs_follow_link,
 865         .put_link = kfree_put_link,
 866         .permission = cifs_permission,
 867         /* BB add the following two eventually */
 868         /* revalidate: cifs_revalidate,
 869            setattr:    cifs_notify_change, *//* BB do we need notify change */
 870 #ifdef CONFIG_CIFS_XATTR
 871         .setxattr = cifs_setxattr,
 872         .getxattr = cifs_getxattr,
 873         .listxattr = cifs_listxattr,
 874         .removexattr = cifs_removexattr,
 875 #endif
 876 };
 877
 878 const struct file_operations cifs_file_ops = {
 879         .read = do_sync_read,
 880         .write = do_sync_write,
 881         .aio_read = generic_file_aio_read,
 882         .aio_write = cifs_file_aio_write,
 883         .open = cifs_open,
 884         .release = cifs_close,
 885         .lock = cifs_lock,
 886         .fsync = cifs_fsync,
 887         .flush = cifs_flush,
 888         .mmap  = cifs_file_mmap,
 889         .splice_read = generic_file_splice_read,
 890         .llseek = cifs_llseek,
 891 #ifdef CONFIG_CIFS_POSIX
 892         .unlocked_ioctl = cifs_ioctl,
 893 #endif /* CONFIG_CIFS_POSIX */
 894         .setlease = cifs_setlease,
 895 };
 896
 897 const struct file_operations cifs_file_strict_ops = {
 898         .read = do_sync_read,
 899         .write = do_sync_write,
 900         .aio_read = cifs_strict_readv,
 901         .aio_write = cifs_strict_writev,
 902         .open = cifs_open,
 903         .release = cifs_close,
 904         .lock = cifs_lock,
 905         .fsync = cifs_strict_fsync,
 906         .flush = cifs_flush,
 907         .mmap = cifs_file_strict_mmap,
 908         .splice_read = generic_file_splice_read,
 909         .llseek = cifs_llseek,
 910 #ifdef CONFIG_CIFS_POSIX
 911         .unlocked_ioctl = cifs_ioctl,
 912 #endif /* CONFIG_CIFS_POSIX */
 913         .setlease = cifs_setlease,
 914 };
 915
 916 const struct file_operations cifs_file_direct_ops = {
 917         /* BB reevaluate whether they can be done with directio, no cache */
 918         .read = do_sync_read,
 919         .write = do_sync_write,
 920         .aio_read = cifs_user_readv,
 921         .aio_write = cifs_user_writev,
 922         .open = cifs_open,
 923         .release = cifs_close,
 924         .lock = cifs_lock,
 925         .fsync = cifs_fsync,
 926         .flush = cifs_flush,
 927         .mmap = cifs_file_mmap,
 928         .splice_read = generic_file_splice_read,
 929 #ifdef CONFIG_CIFS_POSIX
 930         .unlocked_ioctl  = cifs_ioctl,
 931 #endif /* CONFIG_CIFS_POSIX */
 932         .llseek = cifs_llseek,
 933         .setlease = cifs_setlease,
 934 };
 935
 936 const struct file_operations cifs_file_nobrl_ops = {
 937         .read = do_sync_read,
 938         .write = do_sync_write,
 939         .aio_read = generic_file_aio_read,
 940         .aio_write = cifs_file_aio_write,
 941         .open = cifs_open,
 942         .release = cifs_close,
 943         .fsync = cifs_fsync,
 944         .flush = cifs_flush,
 945         .mmap  = cifs_file_mmap,
 946         .splice_read = generic_file_splice_read,
 947         .llseek = cifs_llseek,
 948 #ifdef CONFIG_CIFS_POSIX
 949         .unlocked_ioctl = cifs_ioctl,
 950 #endif /* CONFIG_CIFS_POSIX */
 951         .setlease = cifs_setlease,
 952 };
 953
 954 const struct file_operations cifs_file_strict_nobrl_ops = {
 955         .read = do_sync_read,
 956         .write = do_sync_write,
 957         .aio_read = cifs_strict_readv,
 958         .aio_write = cifs_strict_writev,
 959         .open = cifs_open,
 960         .release = cifs_close,
 961         .fsync = cifs_strict_fsync,
 962         .flush = cifs_flush,
 963         .mmap = cifs_file_strict_mmap,
 964         .splice_read = generic_file_splice_read,
 965         .llseek = cifs_llseek,
 966 #ifdef CONFIG_CIFS_POSIX
 967         .unlocked_ioctl = cifs_ioctl,
 968 #endif /* CONFIG_CIFS_POSIX */
 969         .setlease = cifs_setlease,
 970 };
 971
 972 const struct file_operations cifs_file_direct_nobrl_ops = {
 973         /* BB reevaluate whether they can be done with directio, no cache */
 974         .read = do_sync_read,
 975         .write = do_sync_write,
 976         .aio_read = cifs_user_readv,
 977         .aio_write = cifs_user_writev,
 978         .open = cifs_open,
 979         .release = cifs_close,
 980         .fsync = cifs_fsync,
 981         .flush = cifs_flush,
 982         .mmap = cifs_file_mmap,
 983         .splice_read = generic_file_splice_read,
 984 #ifdef CONFIG_CIFS_POSIX
 985         .unlocked_ioctl  = cifs_ioctl,
 986 #endif /* CONFIG_CIFS_POSIX */
 987         .llseek = cifs_llseek,
 988         .setlease = cifs_setlease,
 989 };
 990
 991 const struct file_operations cifs_dir_ops = {
 992         .iterate = cifs_readdir,
 993         .release = cifs_closedir,
 994         .read    = generic_read_dir,
 995         .unlocked_ioctl  = cifs_ioctl,
 996         .llseek = generic_file_llseek,
 997 };
 998
 999 static void
1000 cifs_init_once(void *inode)
1001 {
1002         struct cifsInodeInfo *cifsi = inode;
1003
1004         inode_init_once(&cifsi->vfs_inode);
1005         init_rwsem(&cifsi->lock_sem);
1006 }
1007
1008 static int __init
1009 cifs_init_inodecache(void)
1010 {
1011         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1012                                               sizeof(struct cifsInodeInfo),
1013                                               0, (SLAB_RECLAIM_ACCOUNT|
1014                                                 SLAB_MEM_SPREAD),
1015                                               cifs_init_once);
1016         if (cifs_inode_cachep == NULL)
1017                 return -ENOMEM;
1018
1019         return 0;
1020 }
1021
1022 static void
1023 cifs_destroy_inodecache(void)
1024 {
1025         /*
1026          * Make sure all delayed rcu free inodes are flushed before we
1027          * destroy cache.
1028          */
1029         rcu_barrier();
1030         kmem_cache_destroy(cifs_inode_cachep);
1031 }
1032
1033 static int
1034 cifs_init_request_bufs(void)
1035 {
1036         size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1037 #ifdef CONFIG_CIFS_SMB2
1038         /*
1039          * SMB2 maximum header size is bigger than CIFS one - no problems to
1040          * allocate some more bytes for CIFS.
1041          */
1042         max_hdr_size = MAX_SMB2_HDR_SIZE;
1043 #endif
1044         if (CIFSMaxBufSize < 8192) {
1045         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1046         Unicode path name has to fit in any SMB/CIFS path based frames */
1047                 CIFSMaxBufSize = 8192;
1048         } else if (CIFSMaxBufSize > 1024*127) {
1049                 CIFSMaxBufSize = 1024 * 127;
1050         } else {
1051                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1052         }
1053 /*
1054         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1055                  CIFSMaxBufSize, CIFSMaxBufSize);
1056 */
1057         cifs_req_cachep = kmem_cache_create("cifs_request",
1058                                             CIFSMaxBufSize + max_hdr_size, 0,
1059                                             SLAB_HWCACHE_ALIGN, NULL);
1060         if (cifs_req_cachep == NULL)
1061                 return -ENOMEM;
1062
1063         if (cifs_min_rcv < 1)
1064                 cifs_min_rcv = 1;
1065         else if (cifs_min_rcv > 64) {
1066                 cifs_min_rcv = 64;
1067                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1068         }
1069
1070         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1071                                                   cifs_req_cachep);
1072
1073         if (cifs_req_poolp == NULL) {
1074                 kmem_cache_destroy(cifs_req_cachep);
1075                 return -ENOMEM;
1076         }
1077         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1078         almost all handle based requests (but not write response, nor is it
1079         sufficient for path based requests).  A smaller size would have
1080         been more efficient (compacting multiple slab items on one 4k page)
1081         for the case in which debug was on, but this larger size allows
1082         more SMBs to use small buffer alloc and is still much more
1083         efficient to alloc 1 per page off the slab compared to 17K (5page)
1084         alloc of large cifs buffers even when page debugging is on */
1085         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1086                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1087                         NULL);
1088         if (cifs_sm_req_cachep == NULL) {
1089                 mempool_destroy(cifs_req_poolp);
1090                 kmem_cache_destroy(cifs_req_cachep);
1091                 return -ENOMEM;
1092         }
1093
1094         if (cifs_min_small < 2)
1095                 cifs_min_small = 2;
1096         else if (cifs_min_small > 256) {
1097                 cifs_min_small = 256;
1098                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1099         }
1100
1101         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1102                                                      cifs_sm_req_cachep);
1103
1104         if (cifs_sm_req_poolp == NULL) {
1105                 mempool_destroy(cifs_req_poolp);
1106                 kmem_cache_destroy(cifs_req_cachep);
1107                 kmem_cache_destroy(cifs_sm_req_cachep);
1108                 return -ENOMEM;
1109         }
1110
1111         return 0;
1112 }
1113
1114 static void
1115 cifs_destroy_request_bufs(void)
1116 {
1117         mempool_destroy(cifs_req_poolp);
1118         kmem_cache_destroy(cifs_req_cachep);
1119         mempool_destroy(cifs_sm_req_poolp);
1120         kmem_cache_destroy(cifs_sm_req_cachep);
1121 }
1122
1123 static int
1124 cifs_init_mids(void)
1125 {
1126         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1127                                             sizeof(struct mid_q_entry), 0,
1128                                             SLAB_HWCACHE_ALIGN, NULL);
1129         if (cifs_mid_cachep == NULL)
1130                 return -ENOMEM;
1131
1132         /* 3 is a reasonable minimum number of simultaneous operations */
1133         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1134         if (cifs_mid_poolp == NULL) {
1135                 kmem_cache_destroy(cifs_mid_cachep);
1136                 return -ENOMEM;
1137         }
1138
1139         return 0;
1140 }
1141
1142 static void
1143 cifs_destroy_mids(void)
1144 {
1145         mempool_destroy(cifs_mid_poolp);
1146         kmem_cache_destroy(cifs_mid_cachep);
1147 }
1148
1149 static int __init
1150 init_cifs(void)
1151 {
1152         int rc = 0;
1153         cifs_proc_init();
1154         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1155 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1156         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1157         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1158 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1159 /*
1160  *  Initialize Global counters
1161  */
1162         atomic_set(&sesInfoAllocCount, 0);
1163         atomic_set(&tconInfoAllocCount, 0);
1164         atomic_set(&tcpSesAllocCount, 0);
1165         atomic_set(&tcpSesReconnectCount, 0);
1166         atomic_set(&tconInfoReconnectCount, 0);
1167
1168         atomic_set(&bufAllocCount, 0);
1169         atomic_set(&smBufAllocCount, 0);
1170 #ifdef CONFIG_CIFS_STATS2
1171         atomic_set(&totBufAllocCount, 0);
1172         atomic_set(&totSmBufAllocCount, 0);
1173 #endif /* CONFIG_CIFS_STATS2 */
1174
1175         atomic_set(&midCount, 0);
1176         GlobalCurrentXid = 0;
1177         GlobalTotalActiveXid = 0;
1178         GlobalMaxActiveXid = 0;
1179         spin_lock_init(&cifs_tcp_ses_lock);
1180         spin_lock_init(&cifs_file_list_lock);
1181         spin_lock_init(&GlobalMid_Lock);
1182
1183 #ifdef CONFIG_CIFS_SMB2
1184         get_random_bytes(cifs_client_guid, SMB2_CLIENT_GUID_SIZE);
1185 #endif
1186
1187         if (cifs_max_pending < 2) {
1188                 cifs_max_pending = 2;
1189                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1190         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1191                 cifs_max_pending = CIFS_MAX_REQ;
1192                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1193                          CIFS_MAX_REQ);
1194         }
1195
1196         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1197         if (!cifsiod_wq) {
1198                 rc = -ENOMEM;
1199                 goto out_clean_proc;
1200         }
1201
1202         rc = cifs_fscache_register();
1203         if (rc)
1204                 goto out_destroy_wq;
1205
1206         rc = cifs_init_inodecache();
1207         if (rc)
1208                 goto out_unreg_fscache;
1209
1210         rc = cifs_init_mids();
1211         if (rc)
1212                 goto out_destroy_inodecache;
1213
1214         rc = cifs_init_request_bufs();
1215         if (rc)
1216                 goto out_destroy_mids;
1217
1218 #ifdef CONFIG_CIFS_UPCALL
1219         rc = register_key_type(&cifs_spnego_key_type);
1220         if (rc)
1221                 goto out_destroy_request_bufs;
1222 #endif /* CONFIG_CIFS_UPCALL */
1223
1224 #ifdef CONFIG_CIFS_ACL
1225         rc = init_cifs_idmap();
1226         if (rc)
1227                 goto out_register_key_type;
1228 #endif /* CONFIG_CIFS_ACL */
1229
1230         rc = register_filesystem(&cifs_fs_type);
1231         if (rc)
1232                 goto out_init_cifs_idmap;
1233
1234         return 0;
1235
1236 out_init_cifs_idmap:
1237 #ifdef CONFIG_CIFS_ACL
1238         exit_cifs_idmap();
1239 out_register_key_type:
1240 #endif
1241 #ifdef CONFIG_CIFS_UPCALL
1242         unregister_key_type(&cifs_spnego_key_type);
1243 out_destroy_request_bufs:
1244 #endif
1245         cifs_destroy_request_bufs();
1246 out_destroy_mids:
1247         cifs_destroy_mids();
1248 out_destroy_inodecache:
1249         cifs_destroy_inodecache();
1250 out_unreg_fscache:
1251         cifs_fscache_unregister();
1252 out_destroy_wq:
1253         destroy_workqueue(cifsiod_wq);
1254 out_clean_proc:
1255         cifs_proc_clean();
1256         return rc;
1257 }
1258
1259 static void __exit
1260 exit_cifs(void)
1261 {
1262         cifs_dbg(NOISY, "exit_cifs\n");
1263         unregister_filesystem(&cifs_fs_type);
1264         cifs_dfs_release_automount_timer();
1265 #ifdef CONFIG_CIFS_ACL
1266         exit_cifs_idmap();
1267 #endif
1268 #ifdef CONFIG_CIFS_UPCALL
1269         unregister_key_type(&cifs_spnego_key_type);
1270 #endif
1271         cifs_destroy_request_bufs();
1272         cifs_destroy_mids();
1273         cifs_destroy_inodecache();
1274         cifs_fscache_unregister();
1275         destroy_workqueue(cifsiod_wq);
1276         cifs_proc_clean();
1277 }
1278
1279 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1280 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1281 MODULE_DESCRIPTION
1282     ("VFS to access servers complying with the SNIA CIFS Specification "
1283      "e.g. Samba and Windows");
1284 MODULE_VERSION(CIFS_VERSION);
1285 module_init(init_cifs)
1286 module_exit(exit_cifs)