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