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 /*      revalidate:cifs_revalidate,   */
 894         .setattr = cifs_setattr,
 895         .symlink = cifs_symlink,
 896         .mknod   = cifs_mknod,
 897         .setxattr = generic_setxattr,
 898         .getxattr = generic_getxattr,
 899         .listxattr = cifs_listxattr,
 900         .removexattr = generic_removexattr,
 901 };
 902
 903 const struct inode_operations cifs_file_inode_ops = {
 904 /*      revalidate:cifs_revalidate, */
 905         .setattr = cifs_setattr,
 906         .getattr = cifs_getattr, /* do we need this anymore? */
 907         .permission = cifs_permission,
 908         .setxattr = generic_setxattr,
 909         .getxattr = generic_getxattr,
 910         .listxattr = cifs_listxattr,
 911         .removexattr = generic_removexattr,
 912 };
 913
 914 const struct inode_operations cifs_symlink_inode_ops = {
 915         .readlink = generic_readlink,
 916         .get_link = cifs_get_link,
 917         .permission = cifs_permission,
 918         /* BB add the following two eventually */
 919         /* revalidate: cifs_revalidate,
 920            setattr:    cifs_notify_change, *//* BB do we need notify change */
 921         .setxattr = generic_setxattr,
 922         .getxattr = generic_getxattr,
 923         .listxattr = cifs_listxattr,
 924         .removexattr = generic_removexattr,
 925 };
 926
 927 static int cifs_clone_file_range(struct file *src_file, loff_t off,
 928                 struct file *dst_file, loff_t destoff, u64 len)
 929 {
 930         struct inode *src_inode = file_inode(src_file);
 931         struct inode *target_inode = file_inode(dst_file);
 932         struct cifsFileInfo *smb_file_src = src_file->private_data;
 933         struct cifsFileInfo *smb_file_target = dst_file->private_data;
 934         struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
 935         unsigned int xid;
 936         int rc;
 937
 938         cifs_dbg(FYI, "clone range\n");
 939
 940         xid = get_xid();
 941
 942         if (!src_file->private_data || !dst_file->private_data) {
 943                 rc = -EBADF;
 944                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
 945                 goto out;
 946         }
 947
 948         /*
 949          * Note: cifs case is easier than btrfs since server responsible for
 950          * checks for proper open modes and file type and if it wants
 951          * server could even support copy of range where source = target
 952          */
 953         lock_two_nondirectories(target_inode, src_inode);
 954
 955         if (len == 0)
 956                 len = src_inode->i_size - off;
 957
 958         cifs_dbg(FYI, "about to flush pages\n");
 959         /* should we flush first and last page first */
 960         truncate_inode_pages_range(&target_inode->i_data, destoff,
 961                                    PAGE_ALIGN(destoff + len)-1);
 962
 963         if (target_tcon->ses->server->ops->duplicate_extents)
 964                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
 965                         smb_file_src, smb_file_target, off, len, destoff);
 966         else
 967                 rc = -EOPNOTSUPP;
 968
 969         /* force revalidate of size and timestamps of target file now
 970            that target is updated on the server */
 971         CIFS_I(target_inode)->time = 0;
 972         /* although unlocking in the reverse order from locking is not
 973            strictly necessary here it is a little cleaner to be consistent */
 974         unlock_two_nondirectories(src_inode, target_inode);
 975 out:
 976         free_xid(xid);
 977         return rc;
 978 }
 979
 980 const struct file_operations cifs_file_ops = {
 981         .read_iter = cifs_loose_read_iter,
 982         .write_iter = cifs_file_write_iter,
 983         .open = cifs_open,
 984         .release = cifs_close,
 985         .lock = cifs_lock,
 986         .fsync = cifs_fsync,
 987         .flush = cifs_flush,
 988         .mmap  = cifs_file_mmap,
 989         .splice_read = generic_file_splice_read,
 990         .llseek = cifs_llseek,
 991         .unlocked_ioctl = cifs_ioctl,
 992         .clone_file_range = cifs_clone_file_range,
 993         .setlease = cifs_setlease,
 994         .fallocate = cifs_fallocate,
 995 };
 996
 997 const struct file_operations cifs_file_strict_ops = {
 998         .read_iter = cifs_strict_readv,
 999         .write_iter = cifs_strict_writev,
1000         .open = cifs_open,
1001         .release = cifs_close,
1002         .lock = cifs_lock,
1003         .fsync = cifs_strict_fsync,
1004         .flush = cifs_flush,
1005         .mmap = cifs_file_strict_mmap,
1006         .splice_read = generic_file_splice_read,
1007         .llseek = cifs_llseek,
1008         .unlocked_ioctl = cifs_ioctl,
1009         .clone_file_range = cifs_clone_file_range,
1010         .setlease = cifs_setlease,
1011         .fallocate = cifs_fallocate,
1012 };
1013
1014 const struct file_operations cifs_file_direct_ops = {
1015         /* BB reevaluate whether they can be done with directio, no cache */
1016         .read_iter = cifs_user_readv,
1017         .write_iter = cifs_user_writev,
1018         .open = cifs_open,
1019         .release = cifs_close,
1020         .lock = cifs_lock,
1021         .fsync = cifs_fsync,
1022         .flush = cifs_flush,
1023         .mmap = cifs_file_mmap,
1024         .splice_read = generic_file_splice_read,
1025         .unlocked_ioctl  = cifs_ioctl,
1026         .clone_file_range = cifs_clone_file_range,
1027         .llseek = cifs_llseek,
1028         .setlease = cifs_setlease,
1029         .fallocate = cifs_fallocate,
1030 };
1031
1032 const struct file_operations cifs_file_nobrl_ops = {
1033         .read_iter = cifs_loose_read_iter,
1034         .write_iter = cifs_file_write_iter,
1035         .open = cifs_open,
1036         .release = cifs_close,
1037         .fsync = cifs_fsync,
1038         .flush = cifs_flush,
1039         .mmap  = cifs_file_mmap,
1040         .splice_read = generic_file_splice_read,
1041         .llseek = cifs_llseek,
1042         .unlocked_ioctl = cifs_ioctl,
1043         .clone_file_range = cifs_clone_file_range,
1044         .setlease = cifs_setlease,
1045         .fallocate = cifs_fallocate,
1046 };
1047
1048 const struct file_operations cifs_file_strict_nobrl_ops = {
1049         .read_iter = cifs_strict_readv,
1050         .write_iter = cifs_strict_writev,
1051         .open = cifs_open,
1052         .release = cifs_close,
1053         .fsync = cifs_strict_fsync,
1054         .flush = cifs_flush,
1055         .mmap = cifs_file_strict_mmap,
1056         .splice_read = generic_file_splice_read,
1057         .llseek = cifs_llseek,
1058         .unlocked_ioctl = cifs_ioctl,
1059         .clone_file_range = cifs_clone_file_range,
1060         .setlease = cifs_setlease,
1061         .fallocate = cifs_fallocate,
1062 };
1063
1064 const struct file_operations cifs_file_direct_nobrl_ops = {
1065         /* BB reevaluate whether they can be done with directio, no cache */
1066         .read_iter = cifs_user_readv,
1067         .write_iter = cifs_user_writev,
1068         .open = cifs_open,
1069         .release = cifs_close,
1070         .fsync = cifs_fsync,
1071         .flush = cifs_flush,
1072         .mmap = cifs_file_mmap,
1073         .splice_read = generic_file_splice_read,
1074         .unlocked_ioctl  = cifs_ioctl,
1075         .clone_file_range = cifs_clone_file_range,
1076         .llseek = cifs_llseek,
1077         .setlease = cifs_setlease,
1078         .fallocate = cifs_fallocate,
1079 };
1080
1081 const struct file_operations cifs_dir_ops = {
1082         .iterate_shared = cifs_readdir,
1083         .release = cifs_closedir,
1084         .read    = generic_read_dir,
1085         .unlocked_ioctl  = cifs_ioctl,
1086         .clone_file_range = cifs_clone_file_range,
1087         .llseek = generic_file_llseek,
1088 };
1089
1090 static void
1091 cifs_init_once(void *inode)
1092 {
1093         struct cifsInodeInfo *cifsi = inode;
1094
1095         inode_init_once(&cifsi->vfs_inode);
1096         init_rwsem(&cifsi->lock_sem);
1097 }
1098
1099 static int __init
1100 cifs_init_inodecache(void)
1101 {
1102         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1103                                               sizeof(struct cifsInodeInfo),
1104                                               0, (SLAB_RECLAIM_ACCOUNT|
1105                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1106                                               cifs_init_once);
1107         if (cifs_inode_cachep == NULL)
1108                 return -ENOMEM;
1109
1110         return 0;
1111 }
1112
1113 static void
1114 cifs_destroy_inodecache(void)
1115 {
1116         /*
1117          * Make sure all delayed rcu free inodes are flushed before we
1118          * destroy cache.
1119          */
1120         rcu_barrier();
1121         kmem_cache_destroy(cifs_inode_cachep);
1122 }
1123
1124 static int
1125 cifs_init_request_bufs(void)
1126 {
1127         size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1128 #ifdef CONFIG_CIFS_SMB2
1129         /*
1130          * SMB2 maximum header size is bigger than CIFS one - no problems to
1131          * allocate some more bytes for CIFS.
1132          */
1133         max_hdr_size = MAX_SMB2_HDR_SIZE;
1134 #endif
1135         if (CIFSMaxBufSize < 8192) {
1136         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1137         Unicode path name has to fit in any SMB/CIFS path based frames */
1138                 CIFSMaxBufSize = 8192;
1139         } else if (CIFSMaxBufSize > 1024*127) {
1140                 CIFSMaxBufSize = 1024 * 127;
1141         } else {
1142                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1143         }
1144 /*
1145         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1146                  CIFSMaxBufSize, CIFSMaxBufSize);
1147 */
1148         cifs_req_cachep = kmem_cache_create("cifs_request",
1149                                             CIFSMaxBufSize + max_hdr_size, 0,
1150                                             SLAB_HWCACHE_ALIGN, NULL);
1151         if (cifs_req_cachep == NULL)
1152                 return -ENOMEM;
1153
1154         if (cifs_min_rcv < 1)
1155                 cifs_min_rcv = 1;
1156         else if (cifs_min_rcv > 64) {
1157                 cifs_min_rcv = 64;
1158                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1159         }
1160
1161         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1162                                                   cifs_req_cachep);
1163
1164         if (cifs_req_poolp == NULL) {
1165                 kmem_cache_destroy(cifs_req_cachep);
1166                 return -ENOMEM;
1167         }
1168         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1169         almost all handle based requests (but not write response, nor is it
1170         sufficient for path based requests).  A smaller size would have
1171         been more efficient (compacting multiple slab items on one 4k page)
1172         for the case in which debug was on, but this larger size allows
1173         more SMBs to use small buffer alloc and is still much more
1174         efficient to alloc 1 per page off the slab compared to 17K (5page)
1175         alloc of large cifs buffers even when page debugging is on */
1176         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1177                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1178                         NULL);
1179         if (cifs_sm_req_cachep == NULL) {
1180                 mempool_destroy(cifs_req_poolp);
1181                 kmem_cache_destroy(cifs_req_cachep);
1182                 return -ENOMEM;
1183         }
1184
1185         if (cifs_min_small < 2)
1186                 cifs_min_small = 2;
1187         else if (cifs_min_small > 256) {
1188                 cifs_min_small = 256;
1189                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1190         }
1191
1192         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1193                                                      cifs_sm_req_cachep);
1194
1195         if (cifs_sm_req_poolp == NULL) {
1196                 mempool_destroy(cifs_req_poolp);
1197                 kmem_cache_destroy(cifs_req_cachep);
1198                 kmem_cache_destroy(cifs_sm_req_cachep);
1199                 return -ENOMEM;
1200         }
1201
1202         return 0;
1203 }
1204
1205 static void
1206 cifs_destroy_request_bufs(void)
1207 {
1208         mempool_destroy(cifs_req_poolp);
1209         kmem_cache_destroy(cifs_req_cachep);
1210         mempool_destroy(cifs_sm_req_poolp);
1211         kmem_cache_destroy(cifs_sm_req_cachep);
1212 }
1213
1214 static int
1215 cifs_init_mids(void)
1216 {
1217         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1218                                             sizeof(struct mid_q_entry), 0,
1219                                             SLAB_HWCACHE_ALIGN, NULL);
1220         if (cifs_mid_cachep == NULL)
1221                 return -ENOMEM;
1222
1223         /* 3 is a reasonable minimum number of simultaneous operations */
1224         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1225         if (cifs_mid_poolp == NULL) {
1226                 kmem_cache_destroy(cifs_mid_cachep);
1227                 return -ENOMEM;
1228         }
1229
1230         return 0;
1231 }
1232
1233 static void
1234 cifs_destroy_mids(void)
1235 {
1236         mempool_destroy(cifs_mid_poolp);
1237         kmem_cache_destroy(cifs_mid_cachep);
1238 }
1239
1240 static int __init
1241 init_cifs(void)
1242 {
1243         int rc = 0;
1244         cifs_proc_init();
1245         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1246 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1247         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1248         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1249 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1250 /*
1251  *  Initialize Global counters
1252  */
1253         atomic_set(&sesInfoAllocCount, 0);
1254         atomic_set(&tconInfoAllocCount, 0);
1255         atomic_set(&tcpSesAllocCount, 0);
1256         atomic_set(&tcpSesReconnectCount, 0);
1257         atomic_set(&tconInfoReconnectCount, 0);
1258
1259         atomic_set(&bufAllocCount, 0);
1260         atomic_set(&smBufAllocCount, 0);
1261 #ifdef CONFIG_CIFS_STATS2
1262         atomic_set(&totBufAllocCount, 0);
1263         atomic_set(&totSmBufAllocCount, 0);
1264 #endif /* CONFIG_CIFS_STATS2 */
1265
1266         atomic_set(&midCount, 0);
1267         GlobalCurrentXid = 0;
1268         GlobalTotalActiveXid = 0;
1269         GlobalMaxActiveXid = 0;
1270         spin_lock_init(&cifs_tcp_ses_lock);
1271         spin_lock_init(&cifs_file_list_lock);
1272         spin_lock_init(&GlobalMid_Lock);
1273
1274         if (cifs_max_pending < 2) {
1275                 cifs_max_pending = 2;
1276                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1277         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1278                 cifs_max_pending = CIFS_MAX_REQ;
1279                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1280                          CIFS_MAX_REQ);
1281         }
1282
1283         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1284         if (!cifsiod_wq) {
1285                 rc = -ENOMEM;
1286                 goto out_clean_proc;
1287         }
1288
1289         rc = cifs_fscache_register();
1290         if (rc)
1291                 goto out_destroy_wq;
1292
1293         rc = cifs_init_inodecache();
1294         if (rc)
1295                 goto out_unreg_fscache;
1296
1297         rc = cifs_init_mids();
1298         if (rc)
1299                 goto out_destroy_inodecache;
1300
1301         rc = cifs_init_request_bufs();
1302         if (rc)
1303                 goto out_destroy_mids;
1304
1305 #ifdef CONFIG_CIFS_UPCALL
1306         rc = register_key_type(&cifs_spnego_key_type);
1307         if (rc)
1308                 goto out_destroy_request_bufs;
1309 #endif /* CONFIG_CIFS_UPCALL */
1310
1311 #ifdef CONFIG_CIFS_ACL
1312         rc = init_cifs_idmap();
1313         if (rc)
1314                 goto out_register_key_type;
1315 #endif /* CONFIG_CIFS_ACL */
1316
1317         rc = register_filesystem(&cifs_fs_type);
1318         if (rc)
1319                 goto out_init_cifs_idmap;
1320
1321         return 0;
1322
1323 out_init_cifs_idmap:
1324 #ifdef CONFIG_CIFS_ACL
1325         exit_cifs_idmap();
1326 out_register_key_type:
1327 #endif
1328 #ifdef CONFIG_CIFS_UPCALL
1329         unregister_key_type(&cifs_spnego_key_type);
1330 out_destroy_request_bufs:
1331 #endif
1332         cifs_destroy_request_bufs();
1333 out_destroy_mids:
1334         cifs_destroy_mids();
1335 out_destroy_inodecache:
1336         cifs_destroy_inodecache();
1337 out_unreg_fscache:
1338         cifs_fscache_unregister();
1339 out_destroy_wq:
1340         destroy_workqueue(cifsiod_wq);
1341 out_clean_proc:
1342         cifs_proc_clean();
1343         return rc;
1344 }
1345
1346 static void __exit
1347 exit_cifs(void)
1348 {
1349         cifs_dbg(NOISY, "exit_cifs\n");
1350         unregister_filesystem(&cifs_fs_type);
1351         cifs_dfs_release_automount_timer();
1352 #ifdef CONFIG_CIFS_ACL
1353         exit_cifs_idmap();
1354 #endif
1355 #ifdef CONFIG_CIFS_UPCALL
1356         unregister_key_type(&cifs_spnego_key_type);
1357 #endif
1358         cifs_destroy_request_bufs();
1359         cifs_destroy_mids();
1360         cifs_destroy_inodecache();
1361         cifs_fscache_unregister();
1362         destroy_workqueue(cifsiod_wq);
1363         cifs_proc_clean();
1364 }
1365
1366 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1367 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1368 MODULE_DESCRIPTION
1369     ("VFS to access servers complying with the SNIA CIFS Specification "
1370      "e.g. Samba and Windows");
1371 MODULE_VERSION(CIFS_VERSION);
1372 module_init(init_cifs)
1373 module_exit(exit_cifs)