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