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, 0444);
  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, 0444);
  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, 0444);
  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 struct workqueue_struct *cifsoplockd_wq;
  91 __u32 cifs_lock_secret;
  92
  93 /*
  94  * Bumps refcount for cifs super block.
  95  * Note that it should be only called if a referece to VFS super block is
  96  * already held, e.g. in open-type syscalls context. Otherwise it can race with
  97  * atomic_dec_and_test in deactivate_locked_super.
  98  */
  99 void
 100 cifs_sb_active(struct super_block *sb)
 101 {
 102         struct cifs_sb_info *server = CIFS_SB(sb);
 103
 104         if (atomic_inc_return(&server->active) == 1)
 105                 atomic_inc(&sb->s_active);
 106 }
 107
 108 void
 109 cifs_sb_deactive(struct super_block *sb)
 110 {
 111         struct cifs_sb_info *server = CIFS_SB(sb);
 112
 113         if (atomic_dec_and_test(&server->active))
 114                 deactivate_super(sb);
 115 }
 116
 117 static int
 118 cifs_read_super(struct super_block *sb)
 119 {
 120         struct inode *inode;
 121         struct cifs_sb_info *cifs_sb;
 122         struct cifs_tcon *tcon;
 123         int rc = 0;
 124
 125         cifs_sb = CIFS_SB(sb);
 126         tcon = cifs_sb_master_tcon(cifs_sb);
 127
 128         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 129                 sb->s_flags |= MS_POSIXACL;
 130
 131         if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 132                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 133         else
 134                 sb->s_maxbytes = MAX_NON_LFS;
 135
 136         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
 137         sb->s_time_gran = 100;
 138
 139         sb->s_magic = CIFS_MAGIC_NUMBER;
 140         sb->s_op = &cifs_super_ops;
 141         sb->s_xattr = cifs_xattr_handlers;
 142         sb->s_bdi = &cifs_sb->bdi;
 143         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 144         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 145         inode = cifs_root_iget(sb);
 146
 147         if (IS_ERR(inode)) {
 148                 rc = PTR_ERR(inode);
 149                 goto out_no_root;
 150         }
 151
 152         if (tcon->nocase)
 153                 sb->s_d_op = &cifs_ci_dentry_ops;
 154         else
 155                 sb->s_d_op = &cifs_dentry_ops;
 156
 157         sb->s_root = d_make_root(inode);
 158         if (!sb->s_root) {
 159                 rc = -ENOMEM;
 160                 goto out_no_root;
 161         }
 162
 163 #ifdef CONFIG_CIFS_NFSD_EXPORT
 164         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 165                 cifs_dbg(FYI, "export ops supported\n");
 166                 sb->s_export_op = &cifs_export_ops;
 167         }
 168 #endif /* CONFIG_CIFS_NFSD_EXPORT */
 169
 170         return 0;
 171
 172 out_no_root:
 173         cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 174         return rc;
 175 }
 176
 177 static void cifs_kill_sb(struct super_block *sb)
 178 {
 179         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 180         kill_anon_super(sb);
 181         cifs_umount(cifs_sb);
 182 }
 183
 184 static int
 185 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 186 {
 187         struct super_block *sb = dentry->d_sb;
 188         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 189         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 190         struct TCP_Server_Info *server = tcon->ses->server;
 191         unsigned int xid;
 192         int rc = 0;
 193
 194         xid = get_xid();
 195
 196         /*
 197          * PATH_MAX may be too long - it would presumably be total path,
 198          * but note that some servers (includinng Samba 3) have a shorter
 199          * maximum path.
 200          *
 201          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
 202          */
 203         buf->f_namelen = PATH_MAX;
 204         buf->f_files = 0;       /* undefined */
 205         buf->f_ffree = 0;       /* unlimited */
 206
 207         if (server->ops->queryfs)
 208                 rc = server->ops->queryfs(xid, tcon, buf);
 209
 210         free_xid(xid);
 211         return rc;
 212 }
 213
 214 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 215 {
 216         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 217         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 218         struct TCP_Server_Info *server = tcon->ses->server;
 219
 220         if (server->ops->fallocate)
 221                 return server->ops->fallocate(file, tcon, mode, off, len);
 222
 223         return -EOPNOTSUPP;
 224 }
 225
 226 static int cifs_permission(struct inode *inode, int mask)
 227 {
 228         struct cifs_sb_info *cifs_sb;
 229
 230         cifs_sb = CIFS_SB(inode->i_sb);
 231
 232         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 233                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 234                         return -EACCES;
 235                 else
 236                         return 0;
 237         } else /* file mode might have been restricted at mount time
 238                 on the client (above and beyond ACL on servers) for
 239                 servers which do not support setting and viewing mode bits,
 240                 so allowing client to check permissions is useful */
 241                 return generic_permission(inode, mask);
 242 }
 243
 244 static struct kmem_cache *cifs_inode_cachep;
 245 static struct kmem_cache *cifs_req_cachep;
 246 static struct kmem_cache *cifs_mid_cachep;
 247 static struct kmem_cache *cifs_sm_req_cachep;
 248 mempool_t *cifs_sm_req_poolp;
 249 mempool_t *cifs_req_poolp;
 250 mempool_t *cifs_mid_poolp;
 251
 252 static struct inode *
 253 cifs_alloc_inode(struct super_block *sb)
 254 {
 255         struct cifsInodeInfo *cifs_inode;
 256         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 257         if (!cifs_inode)
 258                 return NULL;
 259         cifs_inode->cifsAttrs = 0x20;   /* default */
 260         cifs_inode->time = 0;
 261         /*
 262          * Until the file is open and we have gotten oplock info back from the
 263          * server, can not assume caching of file data or metadata.
 264          */
 265         cifs_set_oplock_level(cifs_inode, 0);
 266         cifs_inode->flags = 0;
 267         spin_lock_init(&cifs_inode->writers_lock);
 268         cifs_inode->writers = 0;
 269         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 270         cifs_inode->server_eof = 0;
 271         cifs_inode->uniqueid = 0;
 272         cifs_inode->createtime = 0;
 273         cifs_inode->epoch = 0;
 274 #ifdef CONFIG_CIFS_SMB2
 275         generate_random_uuid(cifs_inode->lease_key);
 276 #endif
 277         /*
 278          * Can not set i_flags here - they get immediately overwritten to zero
 279          * by the VFS.
 280          */
 281         /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 282         INIT_LIST_HEAD(&cifs_inode->openFileList);
 283         INIT_LIST_HEAD(&cifs_inode->llist);
 284         return &cifs_inode->vfs_inode;
 285 }
 286
 287 static void cifs_i_callback(struct rcu_head *head)
 288 {
 289         struct inode *inode = container_of(head, struct inode, i_rcu);
 290         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 291 }
 292
 293 static void
 294 cifs_destroy_inode(struct inode *inode)
 295 {
 296         call_rcu(&inode->i_rcu, cifs_i_callback);
 297 }
 298
 299 static void
 300 cifs_evict_inode(struct inode *inode)
 301 {
 302         truncate_inode_pages_final(&inode->i_data);
 303         clear_inode(inode);
 304         cifs_fscache_release_inode_cookie(inode);
 305 }
 306
 307 static void
 308 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 309 {
 310         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 311         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 312
 313         seq_puts(s, ",addr=");
 314
 315         switch (server->dstaddr.ss_family) {
 316         case AF_INET:
 317                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 318                 break;
 319         case AF_INET6:
 320                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 321                 if (sa6->sin6_scope_id)
 322                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 323                 break;
 324         default:
 325                 seq_puts(s, "(unknown)");
 326         }
 327 }
 328
 329 static void
 330 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 331 {
 332         if (ses->sectype == Unspecified) {
 333                 if (ses->user_name == NULL)
 334                         seq_puts(s, ",sec=none");
 335                 return;
 336         }
 337
 338         seq_puts(s, ",sec=");
 339
 340         switch (ses->sectype) {
 341         case LANMAN:
 342                 seq_puts(s, "lanman");
 343                 break;
 344         case NTLMv2:
 345                 seq_puts(s, "ntlmv2");
 346                 break;
 347         case NTLM:
 348                 seq_puts(s, "ntlm");
 349                 break;
 350         case Kerberos:
 351                 seq_puts(s, "krb5");
 352                 break;
 353         case RawNTLMSSP:
 354                 seq_puts(s, "ntlmssp");
 355                 break;
 356         default:
 357                 /* shouldn't ever happen */
 358                 seq_puts(s, "unknown");
 359                 break;
 360         }
 361
 362         if (ses->sign)
 363                 seq_puts(s, "i");
 364 }
 365
 366 static void
 367 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 368 {
 369         seq_puts(s, ",cache=");
 370
 371         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 372                 seq_puts(s, "strict");
 373         else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 374                 seq_puts(s, "none");
 375         else
 376                 seq_puts(s, "loose");
 377 }
 378
 379 static void
 380 cifs_show_nls(struct seq_file *s, struct nls_table *cur)
 381 {
 382         struct nls_table *def;
 383
 384         /* Display iocharset= option if it's not default charset */
 385         def = load_nls_default();
 386         if (def != cur)
 387                 seq_printf(s, ",iocharset=%s", cur->charset);
 388         unload_nls(def);
 389 }
 390
 391 /*
 392  * cifs_show_options() is for displaying mount options in /proc/mounts.
 393  * Not all settable options are displayed but most of the important
 394  * ones are.
 395  */
 396 static int
 397 cifs_show_options(struct seq_file *s, struct dentry *root)
 398 {
 399         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 400         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 401         struct sockaddr *srcaddr;
 402         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 403
 404         seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
 405         cifs_show_security(s, tcon->ses);
 406         cifs_show_cache_flavor(s, cifs_sb);
 407
 408         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 409                 seq_puts(s, ",multiuser");
 410         else if (tcon->ses->user_name)
 411                 seq_show_option(s, "username", tcon->ses->user_name);
 412
 413         if (tcon->ses->domainName)
 414                 seq_show_option(s, "domain", tcon->ses->domainName);
 415
 416         if (srcaddr->sa_family != AF_UNSPEC) {
 417                 struct sockaddr_in *saddr4;
 418                 struct sockaddr_in6 *saddr6;
 419                 saddr4 = (struct sockaddr_in *)srcaddr;
 420                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 421                 if (srcaddr->sa_family == AF_INET6)
 422                         seq_printf(s, ",srcaddr=%pI6c",
 423                                    &saddr6->sin6_addr);
 424                 else if (srcaddr->sa_family == AF_INET)
 425                         seq_printf(s, ",srcaddr=%pI4",
 426                                    &saddr4->sin_addr.s_addr);
 427                 else
 428                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 429                                    (int)(srcaddr->sa_family));
 430         }
 431
 432         seq_printf(s, ",uid=%u",
 433                    from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
 434         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 435                 seq_puts(s, ",forceuid");
 436         else
 437                 seq_puts(s, ",noforceuid");
 438
 439         seq_printf(s, ",gid=%u",
 440                    from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
 441         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 442                 seq_puts(s, ",forcegid");
 443         else
 444                 seq_puts(s, ",noforcegid");
 445
 446         cifs_show_address(s, tcon->ses->server);
 447
 448         if (!tcon->unix_ext)
 449                 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 450                                            cifs_sb->mnt_file_mode,
 451                                            cifs_sb->mnt_dir_mode);
 452
 453         cifs_show_nls(s, cifs_sb->local_nls);
 454
 455         if (tcon->seal)
 456                 seq_puts(s, ",seal");
 457         if (tcon->nocase)
 458                 seq_puts(s, ",nocase");
 459         if (tcon->retry)
 460                 seq_puts(s, ",hard");
 461         if (tcon->use_persistent)
 462                 seq_puts(s, ",persistenthandles");
 463         else if (tcon->use_resilient)
 464                 seq_puts(s, ",resilienthandles");
 465         if (tcon->unix_ext)
 466                 seq_puts(s, ",unix");
 467         else
 468                 seq_puts(s, ",nounix");
 469         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 470                 seq_puts(s, ",posixpaths");
 471         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 472                 seq_puts(s, ",setuids");
 473         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
 474                 seq_puts(s, ",idsfromsid");
 475         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 476                 seq_puts(s, ",serverino");
 477         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 478                 seq_puts(s, ",rwpidforward");
 479         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 480                 seq_puts(s, ",forcemand");
 481         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 482                 seq_puts(s, ",nouser_xattr");
 483         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 484                 seq_puts(s, ",mapchars");
 485         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
 486                 seq_puts(s, ",mapposix");
 487         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 488                 seq_puts(s, ",sfu");
 489         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 490                 seq_puts(s, ",nobrl");
 491         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 492                 seq_puts(s, ",cifsacl");
 493         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 494                 seq_puts(s, ",dynperm");
 495         if (root->d_sb->s_flags & MS_POSIXACL)
 496                 seq_puts(s, ",acl");
 497         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 498                 seq_puts(s, ",mfsymlinks");
 499         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 500                 seq_puts(s, ",fsc");
 501         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 502                 seq_puts(s, ",nostrictsync");
 503         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 504                 seq_puts(s, ",noperm");
 505         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 506                 seq_printf(s, ",backupuid=%u",
 507                            from_kuid_munged(&init_user_ns,
 508                                             cifs_sb->mnt_backupuid));
 509         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 510                 seq_printf(s, ",backupgid=%u",
 511                            from_kgid_munged(&init_user_ns,
 512                                             cifs_sb->mnt_backupgid));
 513
 514         seq_printf(s, ",rsize=%u", cifs_sb->rsize);
 515         seq_printf(s, ",wsize=%u", cifs_sb->wsize);
 516         seq_printf(s, ",echo_interval=%lu",
 517                         tcon->ses->server->echo_interval / HZ);
 518         /* convert actimeo and display it in seconds */
 519         seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 520
 521         return 0;
 522 }
 523
 524 static void cifs_umount_begin(struct super_block *sb)
 525 {
 526         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 527         struct cifs_tcon *tcon;
 528
 529         if (cifs_sb == NULL)
 530                 return;
 531
 532         tcon = cifs_sb_master_tcon(cifs_sb);
 533
 534         spin_lock(&cifs_tcp_ses_lock);
 535         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 536                 /* we have other mounts to same share or we have
 537                    already tried to force umount this and woken up
 538                    all waiting network requests, nothing to do */
 539                 spin_unlock(&cifs_tcp_ses_lock);
 540                 return;
 541         } else if (tcon->tc_count == 1)
 542                 tcon->tidStatus = CifsExiting;
 543         spin_unlock(&cifs_tcp_ses_lock);
 544
 545         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 546         /* cancel_notify_requests(tcon); */
 547         if (tcon->ses && tcon->ses->server) {
 548                 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 549                 wake_up_all(&tcon->ses->server->request_q);
 550                 wake_up_all(&tcon->ses->server->response_q);
 551                 msleep(1); /* yield */
 552                 /* we have to kick the requests once more */
 553                 wake_up_all(&tcon->ses->server->response_q);
 554                 msleep(1);
 555         }
 556
 557         return;
 558 }
 559
 560 #ifdef CONFIG_CIFS_STATS2
 561 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 562 {
 563         /* BB FIXME */
 564         return 0;
 565 }
 566 #endif
 567
 568 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 569 {
 570         sync_filesystem(sb);
 571         *flags |= MS_NODIRATIME;
 572         return 0;
 573 }
 574
 575 static int cifs_drop_inode(struct inode *inode)
 576 {
 577         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 578
 579         /* no serverino => unconditional eviction */
 580         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 581                 generic_drop_inode(inode);
 582 }
 583
 584 static const struct super_operations cifs_super_ops = {
 585         .statfs = cifs_statfs,
 586         .alloc_inode = cifs_alloc_inode,
 587         .destroy_inode = cifs_destroy_inode,
 588         .drop_inode     = cifs_drop_inode,
 589         .evict_inode    = cifs_evict_inode,
 590 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 591         function unless later we add lazy close of inodes or unless the
 592         kernel forgets to call us with the same number of releases (closes)
 593         as opens */
 594         .show_options = cifs_show_options,
 595         .umount_begin   = cifs_umount_begin,
 596         .remount_fs = cifs_remount,
 597 #ifdef CONFIG_CIFS_STATS2
 598         .show_stats = cifs_show_stats,
 599 #endif
 600 };
 601
 602 /*
 603  * Get root dentry from superblock according to prefix path mount option.
 604  * Return dentry with refcount + 1 on success and NULL otherwise.
 605  */
 606 static struct dentry *
 607 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 608 {
 609         struct dentry *dentry;
 610         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 611         char *full_path = NULL;
 612         char *s, *p;
 613         char sep;
 614
 615         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 616                 return dget(sb->s_root);
 617
 618         full_path = cifs_build_path_to_root(vol, cifs_sb,
 619                                             cifs_sb_master_tcon(cifs_sb));
 620         if (full_path == NULL)
 621                 return ERR_PTR(-ENOMEM);
 622
 623         cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 624
 625         sep = CIFS_DIR_SEP(cifs_sb);
 626         dentry = dget(sb->s_root);
 627         p = s = full_path;
 628
 629         do {
 630                 struct inode *dir = d_inode(dentry);
 631                 struct dentry *child;
 632
 633                 if (!dir) {
 634                         dput(dentry);
 635                         dentry = ERR_PTR(-ENOENT);
 636                         break;
 637                 }
 638                 if (!S_ISDIR(dir->i_mode)) {
 639                         dput(dentry);
 640                         dentry = ERR_PTR(-ENOTDIR);
 641                         break;
 642                 }
 643
 644                 /* skip separators */
 645                 while (*s == sep)
 646                         s++;
 647                 if (!*s)
 648                         break;
 649                 p = s++;
 650                 /* next separator */
 651                 while (*s && *s != sep)
 652                         s++;
 653
 654                 child = lookup_one_len_unlocked(p, dentry, s - p);
 655                 dput(dentry);
 656                 dentry = child;
 657         } while (!IS_ERR(dentry));
 658         kfree(full_path);
 659         return dentry;
 660 }
 661
 662 static int cifs_set_super(struct super_block *sb, void *data)
 663 {
 664         struct cifs_mnt_data *mnt_data = data;
 665         sb->s_fs_info = mnt_data->cifs_sb;
 666         return set_anon_super(sb, NULL);
 667 }
 668
 669 static struct dentry *
 670 cifs_do_mount(struct file_system_type *fs_type,
 671               int flags, const char *dev_name, void *data)
 672 {
 673         int rc;
 674         struct super_block *sb;
 675         struct cifs_sb_info *cifs_sb;
 676         struct smb_vol *volume_info;
 677         struct cifs_mnt_data mnt_data;
 678         struct dentry *root;
 679
 680         cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
 681
 682         volume_info = cifs_get_volume_info((char *)data, dev_name);
 683         if (IS_ERR(volume_info))
 684                 return ERR_CAST(volume_info);
 685
 686         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 687         if (cifs_sb == NULL) {
 688                 root = ERR_PTR(-ENOMEM);
 689                 goto out_nls;
 690         }
 691
 692         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 693         if (cifs_sb->mountdata == NULL) {
 694                 root = ERR_PTR(-ENOMEM);
 695                 goto out_free;
 696         }
 697
 698         rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
 699         if (rc) {
 700                 root = ERR_PTR(rc);
 701                 goto out_free;
 702         }
 703
 704         rc = cifs_mount(cifs_sb, volume_info);
 705         if (rc) {
 706                 if (!(flags & MS_SILENT))
 707                         cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 708                                  rc);
 709                 root = ERR_PTR(rc);
 710                 goto out_free;
 711         }
 712
 713         mnt_data.vol = volume_info;
 714         mnt_data.cifs_sb = cifs_sb;
 715         mnt_data.flags = flags;
 716
 717         /* BB should we make this contingent on mount parm? */
 718         flags |= MS_NODIRATIME | MS_NOATIME;
 719
 720         sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 721         if (IS_ERR(sb)) {
 722                 root = ERR_CAST(sb);
 723                 cifs_umount(cifs_sb);
 724                 goto out;
 725         }
 726
 727         if (sb->s_root) {
 728                 cifs_dbg(FYI, "Use existing superblock\n");
 729                 cifs_umount(cifs_sb);
 730         } else {
 731                 rc = cifs_read_super(sb);
 732                 if (rc) {
 733                         root = ERR_PTR(rc);
 734                         goto out_super;
 735                 }
 736
 737                 sb->s_flags |= MS_ACTIVE;
 738         }
 739
 740         root = cifs_get_root(volume_info, sb);
 741         if (IS_ERR(root))
 742                 goto out_super;
 743
 744         cifs_dbg(FYI, "dentry root is: %p\n", root);
 745         goto out;
 746
 747 out_super:
 748         deactivate_locked_super(sb);
 749 out:
 750         cifs_cleanup_volume_info(volume_info);
 751         return root;
 752
 753 out_free:
 754         kfree(cifs_sb->prepath);
 755         kfree(cifs_sb->mountdata);
 756         kfree(cifs_sb);
 757 out_nls:
 758         unload_nls(volume_info->local_nls);
 759         goto out;
 760 }
 761
 762 static ssize_t
 763 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 764 {
 765         ssize_t rc;
 766         struct inode *inode = file_inode(iocb->ki_filp);
 767
 768         if (iocb->ki_filp->f_flags & O_DIRECT)
 769                 return cifs_user_readv(iocb, iter);
 770
 771         rc = cifs_revalidate_mapping(inode);
 772         if (rc)
 773                 return rc;
 774
 775         return generic_file_read_iter(iocb, iter);
 776 }
 777
 778 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 779 {
 780         struct inode *inode = file_inode(iocb->ki_filp);
 781         struct cifsInodeInfo *cinode = CIFS_I(inode);
 782         ssize_t written;
 783         int rc;
 784
 785         if (iocb->ki_filp->f_flags & O_DIRECT) {
 786                 written = cifs_user_writev(iocb, from);
 787                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
 788                         cifs_zap_mapping(inode);
 789                         cifs_dbg(FYI,
 790                                  "Set no oplock for inode=%p after a write operation\n",
 791                                  inode);
 792                         cinode->oplock = 0;
 793                 }
 794                 return written;
 795         }
 796
 797         written = cifs_get_writer(cinode);
 798         if (written)
 799                 return written;
 800
 801         written = generic_file_write_iter(iocb, from);
 802
 803         if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 804                 goto out;
 805
 806         rc = filemap_fdatawrite(inode->i_mapping);
 807         if (rc)
 808                 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 809                          rc, inode);
 810
 811 out:
 812         cifs_put_writer(cinode);
 813         return written;
 814 }
 815
 816 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 817 {
 818         /*
 819          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 820          * the cached file length
 821          */
 822         if (whence != SEEK_SET && whence != SEEK_CUR) {
 823                 int rc;
 824                 struct inode *inode = file_inode(file);
 825
 826                 /*
 827                  * We need to be sure that all dirty pages are written and the
 828                  * server has the newest file length.
 829                  */
 830                 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 831                     inode->i_mapping->nrpages != 0) {
 832                         rc = filemap_fdatawait(inode->i_mapping);
 833                         if (rc) {
 834                                 mapping_set_error(inode->i_mapping, rc);
 835                                 return rc;
 836                         }
 837                 }
 838                 /*
 839                  * Some applications poll for the file length in this strange
 840                  * way so we must seek to end on non-oplocked files by
 841                  * setting the revalidate time to zero.
 842                  */
 843                 CIFS_I(inode)->time = 0;
 844
 845                 rc = cifs_revalidate_file_attr(file);
 846                 if (rc < 0)
 847                         return (loff_t)rc;
 848         }
 849         return generic_file_llseek(file, offset, whence);
 850 }
 851
 852 static int
 853 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 854 {
 855         /*
 856          * Note that this is called by vfs setlease with i_lock held to
 857          * protect *lease from going away.
 858          */
 859         struct inode *inode = file_inode(file);
 860         struct cifsFileInfo *cfile = file->private_data;
 861
 862         if (!(S_ISREG(inode->i_mode)))
 863                 return -EINVAL;
 864
 865         /* Check if file is oplocked if this is request for new lease */
 866         if (arg == F_UNLCK ||
 867             ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 868             ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 869                 return generic_setlease(file, arg, lease, priv);
 870         else if (tlink_tcon(cfile->tlink)->local_lease &&
 871                  !CIFS_CACHE_READ(CIFS_I(inode)))
 872                 /*
 873                  * If the server claims to support oplock on this file, then we
 874                  * still need to check oplock even if the local_lease mount
 875                  * option is set, but there are servers which do not support
 876                  * oplock for which this mount option may be useful if the user
 877                  * knows that the file won't be changed on the server by anyone
 878                  * else.
 879                  */
 880                 return generic_setlease(file, arg, lease, priv);
 881         else
 882                 return -EAGAIN;
 883 }
 884
 885 struct file_system_type cifs_fs_type = {
 886         .owner = THIS_MODULE,
 887         .name = "cifs",
 888         .mount = cifs_do_mount,
 889         .kill_sb = cifs_kill_sb,
 890         /*  .fs_flags */
 891 };
 892 MODULE_ALIAS_FS("cifs");
 893 const struct inode_operations cifs_dir_inode_ops = {
 894         .create = cifs_create,
 895         .atomic_open = cifs_atomic_open,
 896         .lookup = cifs_lookup,
 897         .getattr = cifs_getattr,
 898         .unlink = cifs_unlink,
 899         .link = cifs_hardlink,
 900         .mkdir = cifs_mkdir,
 901         .rmdir = cifs_rmdir,
 902         .rename = cifs_rename2,
 903         .permission = cifs_permission,
 904         .setattr = cifs_setattr,
 905         .symlink = cifs_symlink,
 906         .mknod   = cifs_mknod,
 907         .listxattr = cifs_listxattr,
 908 };
 909
 910 const struct inode_operations cifs_file_inode_ops = {
 911         .setattr = cifs_setattr,
 912         .getattr = cifs_getattr,
 913         .permission = cifs_permission,
 914         .listxattr = cifs_listxattr,
 915 };
 916
 917 const struct inode_operations cifs_symlink_inode_ops = {
 918         .readlink = generic_readlink,
 919         .get_link = cifs_get_link,
 920         .permission = cifs_permission,
 921         .listxattr = cifs_listxattr,
 922 };
 923
 924 static int cifs_clone_file_range(struct file *src_file, loff_t off,
 925                 struct file *dst_file, loff_t destoff, u64 len)
 926 {
 927         struct inode *src_inode = file_inode(src_file);
 928         struct inode *target_inode = file_inode(dst_file);
 929         struct cifsFileInfo *smb_file_src = src_file->private_data;
 930         struct cifsFileInfo *smb_file_target;
 931         struct cifs_tcon *target_tcon;
 932         unsigned int xid;
 933         int rc;
 934
 935         cifs_dbg(FYI, "clone range\n");
 936
 937         xid = get_xid();
 938
 939         if (!src_file->private_data || !dst_file->private_data) {
 940                 rc = -EBADF;
 941                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
 942                 goto out;
 943         }
 944
 945         smb_file_target = dst_file->private_data;
 946         target_tcon = tlink_tcon(smb_file_target->tlink);
 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(&GlobalMid_Lock);
1272
1273         get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
1274
1275         if (cifs_max_pending < 2) {
1276                 cifs_max_pending = 2;
1277                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1278         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1279                 cifs_max_pending = CIFS_MAX_REQ;
1280                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1281                          CIFS_MAX_REQ);
1282         }
1283
1284         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1285         if (!cifsiod_wq) {
1286                 rc = -ENOMEM;
1287                 goto out_clean_proc;
1288         }
1289
1290         cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1291                                          WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1292         if (!cifsoplockd_wq) {
1293                 rc = -ENOMEM;
1294                 goto out_destroy_cifsiod_wq;
1295         }
1296
1297         rc = cifs_fscache_register();
1298         if (rc)
1299                 goto out_destroy_cifsoplockd_wq;
1300
1301         rc = cifs_init_inodecache();
1302         if (rc)
1303                 goto out_unreg_fscache;
1304
1305         rc = cifs_init_mids();
1306         if (rc)
1307                 goto out_destroy_inodecache;
1308
1309         rc = cifs_init_request_bufs();
1310         if (rc)
1311                 goto out_destroy_mids;
1312
1313 #ifdef CONFIG_CIFS_UPCALL
1314         rc = init_cifs_spnego();
1315         if (rc)
1316                 goto out_destroy_request_bufs;
1317 #endif /* CONFIG_CIFS_UPCALL */
1318
1319 #ifdef CONFIG_CIFS_ACL
1320         rc = init_cifs_idmap();
1321         if (rc)
1322                 goto out_register_key_type;
1323 #endif /* CONFIG_CIFS_ACL */
1324
1325         rc = register_filesystem(&cifs_fs_type);
1326         if (rc)
1327                 goto out_init_cifs_idmap;
1328
1329         return 0;
1330
1331 out_init_cifs_idmap:
1332 #ifdef CONFIG_CIFS_ACL
1333         exit_cifs_idmap();
1334 out_register_key_type:
1335 #endif
1336 #ifdef CONFIG_CIFS_UPCALL
1337         exit_cifs_spnego();
1338 out_destroy_request_bufs:
1339 #endif
1340         cifs_destroy_request_bufs();
1341 out_destroy_mids:
1342         cifs_destroy_mids();
1343 out_destroy_inodecache:
1344         cifs_destroy_inodecache();
1345 out_unreg_fscache:
1346         cifs_fscache_unregister();
1347 out_destroy_cifsoplockd_wq:
1348         destroy_workqueue(cifsoplockd_wq);
1349 out_destroy_cifsiod_wq:
1350         destroy_workqueue(cifsiod_wq);
1351 out_clean_proc:
1352         cifs_proc_clean();
1353         return rc;
1354 }
1355
1356 static void __exit
1357 exit_cifs(void)
1358 {
1359         cifs_dbg(NOISY, "exit_cifs\n");
1360         unregister_filesystem(&cifs_fs_type);
1361         cifs_dfs_release_automount_timer();
1362 #ifdef CONFIG_CIFS_ACL
1363         exit_cifs_idmap();
1364 #endif
1365 #ifdef CONFIG_CIFS_UPCALL
1366         exit_cifs_spnego();
1367 #endif
1368         cifs_destroy_request_bufs();
1369         cifs_destroy_mids();
1370         cifs_destroy_inodecache();
1371         cifs_fscache_unregister();
1372         destroy_workqueue(cifsoplockd_wq);
1373         destroy_workqueue(cifsiod_wq);
1374         cifs_proc_clean();
1375 }
1376
1377 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1378 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1379 MODULE_DESCRIPTION
1380     ("VFS to access servers complying with the SNIA CIFS Specification "
1381      "e.g. Samba and Windows");
1382 MODULE_VERSION(CIFS_VERSION);
1383 module_init(init_cifs)
1384 module_exit(exit_cifs)