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 ([email protected])
   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/uuid.h>
  41 #include <linux/xattr.h>
  42 #include <net/ipv6.h>
  43 #include "cifsfs.h"
  44 #include "cifspdu.h"
  45 #define DECLARE_GLOBALS_HERE
  46 #include "cifsglob.h"
  47 #include "cifsproto.h"
  48 #include "cifs_debug.h"
  49 #include "cifs_fs_sb.h"
  50 #include <linux/mm.h>
  51 #include <linux/key-type.h>
  52 #include "cifs_spnego.h"
  53 #include "fscache.h"
  54 #ifdef CONFIG_CIFS_SMB2
  55 #include "smb2pdu.h"
  56 #endif
  57
  58 int cifsFYI = 0;
  59 bool traceSMB;
  60 bool enable_oplocks = true;
  61 bool linuxExtEnabled = true;
  62 bool lookupCacheEnabled = true;
  63 unsigned int global_secflags = CIFSSEC_DEF;
  64 /* unsigned int ntlmv2_support = 0; */
  65 unsigned int sign_CIFS_PDUs = 1;
  66 static const struct super_operations cifs_super_ops;
  67 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  68 module_param(CIFSMaxBufSize, uint, 0444);
  69 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
  70                                  "Default: 16384 Range: 8192 to 130048");
  71 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  72 module_param(cifs_min_rcv, uint, 0444);
  73 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  74                                 "1 to 64");
  75 unsigned int cifs_min_small = 30;
  76 module_param(cifs_min_small, uint, 0444);
  77 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  78                                  "Range: 2 to 256");
  79 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  80 module_param(cifs_max_pending, uint, 0444);
  81 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  82                                    "Default: 32767 Range: 2 to 32767.");
  83 module_param(enable_oplocks, bool, 0644);
  84 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
  85
  86 extern mempool_t *cifs_sm_req_poolp;
  87 extern mempool_t *cifs_req_poolp;
  88 extern mempool_t *cifs_mid_poolp;
  89
  90 struct workqueue_struct *cifsiod_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 0;
 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), 0);
 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         .get_link = cifs_get_link,
 919         .permission = cifs_permission,
 920         .listxattr = cifs_listxattr,
 921 };
 922
 923 static int cifs_clone_file_range(struct file *src_file, loff_t off,
 924                 struct file *dst_file, loff_t destoff, u64 len)
 925 {
 926         struct inode *src_inode = file_inode(src_file);
 927         struct inode *target_inode = file_inode(dst_file);
 928         struct cifsFileInfo *smb_file_src = src_file->private_data;
 929         struct cifsFileInfo *smb_file_target = dst_file->private_data;
 930         struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
 931         unsigned int xid;
 932         int rc;
 933
 934         cifs_dbg(FYI, "clone range\n");
 935
 936         xid = get_xid();
 937
 938         if (!src_file->private_data || !dst_file->private_data) {
 939                 rc = -EBADF;
 940                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
 941                 goto out;
 942         }
 943
 944         /*
 945          * Note: cifs case is easier than btrfs since server responsible for
 946          * checks for proper open modes and file type and if it wants
 947          * server could even support copy of range where source = target
 948          */
 949         lock_two_nondirectories(target_inode, src_inode);
 950
 951         if (len == 0)
 952                 len = src_inode->i_size - off;
 953
 954         cifs_dbg(FYI, "about to flush pages\n");
 955         /* should we flush first and last page first */
 956         truncate_inode_pages_range(&target_inode->i_data, destoff,
 957                                    PAGE_ALIGN(destoff + len)-1);
 958
 959         if (target_tcon->ses->server->ops->duplicate_extents)
 960                 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
 961                         smb_file_src, smb_file_target, off, len, destoff);
 962         else
 963                 rc = -EOPNOTSUPP;
 964
 965         /* force revalidate of size and timestamps of target file now
 966            that target is updated on the server */
 967         CIFS_I(target_inode)->time = 0;
 968         /* although unlocking in the reverse order from locking is not
 969            strictly necessary here it is a little cleaner to be consistent */
 970         unlock_two_nondirectories(src_inode, target_inode);
 971 out:
 972         free_xid(xid);
 973         return rc;
 974 }
 975
 976 ssize_t cifs_file_copychunk_range(unsigned int xid,
 977                                 struct file *src_file, loff_t off,
 978                                 struct file *dst_file, loff_t destoff,
 979                                 size_t len, unsigned int flags)
 980 {
 981         struct inode *src_inode = file_inode(src_file);
 982         struct inode *target_inode = file_inode(dst_file);
 983         struct cifsFileInfo *smb_file_src;
 984         struct cifsFileInfo *smb_file_target;
 985         struct cifs_tcon *src_tcon;
 986         struct cifs_tcon *target_tcon;
 987         ssize_t rc;
 988
 989         cifs_dbg(FYI, "copychunk range\n");
 990
 991         if (src_inode == target_inode) {
 992                 rc = -EINVAL;
 993                 goto out;
 994         }
 995
 996         if (!src_file->private_data || !dst_file->private_data) {
 997                 rc = -EBADF;
 998                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
 999                 goto out;
1000         }
1001
1002         rc = -EXDEV;
1003         smb_file_target = dst_file->private_data;
1004         smb_file_src = src_file->private_data;
1005         src_tcon = tlink_tcon(smb_file_src->tlink);
1006         target_tcon = tlink_tcon(smb_file_target->tlink);
1007
1008         if (src_tcon->ses != target_tcon->ses) {
1009                 cifs_dbg(VFS, "source and target of copy not on same server\n");
1010                 goto out;
1011         }
1012
1013         /*
1014          * Note: cifs case is easier than btrfs since server responsible for
1015          * checks for proper open modes and file type and if it wants
1016          * server could even support copy of range where source = target
1017          */
1018         lock_two_nondirectories(target_inode, src_inode);
1019
1020         cifs_dbg(FYI, "about to flush pages\n");
1021         /* should we flush first and last page first */
1022         truncate_inode_pages(&target_inode->i_data, 0);
1023
1024         if (target_tcon->ses->server->ops->copychunk_range)
1025                 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1026                         smb_file_src, smb_file_target, off, len, destoff);
1027         else
1028                 rc = -EOPNOTSUPP;
1029
1030         /* force revalidate of size and timestamps of target file now
1031          * that target is updated on the server
1032          */
1033         CIFS_I(target_inode)->time = 0;
1034         /* although unlocking in the reverse order from locking is not
1035          * strictly necessary here it is a little cleaner to be consistent
1036          */
1037         unlock_two_nondirectories(src_inode, target_inode);
1038
1039 out:
1040         return rc;
1041 }
1042
1043 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1044                                 struct file *dst_file, loff_t destoff,
1045                                 size_t len, unsigned int flags)
1046 {
1047         unsigned int xid = get_xid();
1048         ssize_t rc;
1049
1050         rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1051                                         len, flags);
1052         free_xid(xid);
1053         return rc;
1054 }
1055
1056 const struct file_operations cifs_file_ops = {
1057         .read_iter = cifs_loose_read_iter,
1058         .write_iter = cifs_file_write_iter,
1059         .open = cifs_open,
1060         .release = cifs_close,
1061         .lock = cifs_lock,
1062         .fsync = cifs_fsync,
1063         .flush = cifs_flush,
1064         .mmap  = cifs_file_mmap,
1065         .splice_read = generic_file_splice_read,
1066         .llseek = cifs_llseek,
1067         .unlocked_ioctl = cifs_ioctl,
1068         .copy_file_range = cifs_copy_file_range,
1069         .clone_file_range = cifs_clone_file_range,
1070         .setlease = cifs_setlease,
1071         .fallocate = cifs_fallocate,
1072 };
1073
1074 const struct file_operations cifs_file_strict_ops = {
1075         .read_iter = cifs_strict_readv,
1076         .write_iter = cifs_strict_writev,
1077         .open = cifs_open,
1078         .release = cifs_close,
1079         .lock = cifs_lock,
1080         .fsync = cifs_strict_fsync,
1081         .flush = cifs_flush,
1082         .mmap = cifs_file_strict_mmap,
1083         .splice_read = generic_file_splice_read,
1084         .llseek = cifs_llseek,
1085         .unlocked_ioctl = cifs_ioctl,
1086         .copy_file_range = cifs_copy_file_range,
1087         .clone_file_range = cifs_clone_file_range,
1088         .setlease = cifs_setlease,
1089         .fallocate = cifs_fallocate,
1090 };
1091
1092 const struct file_operations cifs_file_direct_ops = {
1093         /* BB reevaluate whether they can be done with directio, no cache */
1094         .read_iter = cifs_user_readv,
1095         .write_iter = cifs_user_writev,
1096         .open = cifs_open,
1097         .release = cifs_close,
1098         .lock = cifs_lock,
1099         .fsync = cifs_fsync,
1100         .flush = cifs_flush,
1101         .mmap = cifs_file_mmap,
1102         .splice_read = generic_file_splice_read,
1103         .unlocked_ioctl  = cifs_ioctl,
1104         .copy_file_range = cifs_copy_file_range,
1105         .clone_file_range = cifs_clone_file_range,
1106         .llseek = cifs_llseek,
1107         .setlease = cifs_setlease,
1108         .fallocate = cifs_fallocate,
1109 };
1110
1111 const struct file_operations cifs_file_nobrl_ops = {
1112         .read_iter = cifs_loose_read_iter,
1113         .write_iter = cifs_file_write_iter,
1114         .open = cifs_open,
1115         .release = cifs_close,
1116         .fsync = cifs_fsync,
1117         .flush = cifs_flush,
1118         .mmap  = cifs_file_mmap,
1119         .splice_read = generic_file_splice_read,
1120         .llseek = cifs_llseek,
1121         .unlocked_ioctl = cifs_ioctl,
1122         .copy_file_range = cifs_copy_file_range,
1123         .clone_file_range = cifs_clone_file_range,
1124         .setlease = cifs_setlease,
1125         .fallocate = cifs_fallocate,
1126 };
1127
1128 const struct file_operations cifs_file_strict_nobrl_ops = {
1129         .read_iter = cifs_strict_readv,
1130         .write_iter = cifs_strict_writev,
1131         .open = cifs_open,
1132         .release = cifs_close,
1133         .fsync = cifs_strict_fsync,
1134         .flush = cifs_flush,
1135         .mmap = cifs_file_strict_mmap,
1136         .splice_read = generic_file_splice_read,
1137         .llseek = cifs_llseek,
1138         .unlocked_ioctl = cifs_ioctl,
1139         .copy_file_range = cifs_copy_file_range,
1140         .clone_file_range = cifs_clone_file_range,
1141         .setlease = cifs_setlease,
1142         .fallocate = cifs_fallocate,
1143 };
1144
1145 const struct file_operations cifs_file_direct_nobrl_ops = {
1146         /* BB reevaluate whether they can be done with directio, no cache */
1147         .read_iter = cifs_user_readv,
1148         .write_iter = cifs_user_writev,
1149         .open = cifs_open,
1150         .release = cifs_close,
1151         .fsync = cifs_fsync,
1152         .flush = cifs_flush,
1153         .mmap = cifs_file_mmap,
1154         .splice_read = generic_file_splice_read,
1155         .unlocked_ioctl  = cifs_ioctl,
1156         .copy_file_range = cifs_copy_file_range,
1157         .clone_file_range = cifs_clone_file_range,
1158         .llseek = cifs_llseek,
1159         .setlease = cifs_setlease,
1160         .fallocate = cifs_fallocate,
1161 };
1162
1163 const struct file_operations cifs_dir_ops = {
1164         .iterate_shared = cifs_readdir,
1165         .release = cifs_closedir,
1166         .read    = generic_read_dir,
1167         .unlocked_ioctl  = cifs_ioctl,
1168         .copy_file_range = cifs_copy_file_range,
1169         .clone_file_range = cifs_clone_file_range,
1170         .llseek = generic_file_llseek,
1171 };
1172
1173 static void
1174 cifs_init_once(void *inode)
1175 {
1176         struct cifsInodeInfo *cifsi = inode;
1177
1178         inode_init_once(&cifsi->vfs_inode);
1179         init_rwsem(&cifsi->lock_sem);
1180 }
1181
1182 static int __init
1183 cifs_init_inodecache(void)
1184 {
1185         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1186                                               sizeof(struct cifsInodeInfo),
1187                                               0, (SLAB_RECLAIM_ACCOUNT|
1188                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1189                                               cifs_init_once);
1190         if (cifs_inode_cachep == NULL)
1191                 return -ENOMEM;
1192
1193         return 0;
1194 }
1195
1196 static void
1197 cifs_destroy_inodecache(void)
1198 {
1199         /*
1200          * Make sure all delayed rcu free inodes are flushed before we
1201          * destroy cache.
1202          */
1203         rcu_barrier();
1204         kmem_cache_destroy(cifs_inode_cachep);
1205 }
1206
1207 static int
1208 cifs_init_request_bufs(void)
1209 {
1210         size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1211 #ifdef CONFIG_CIFS_SMB2
1212         /*
1213          * SMB2 maximum header size is bigger than CIFS one - no problems to
1214          * allocate some more bytes for CIFS.
1215          */
1216         max_hdr_size = MAX_SMB2_HDR_SIZE;
1217 #endif
1218         if (CIFSMaxBufSize < 8192) {
1219         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1220         Unicode path name has to fit in any SMB/CIFS path based frames */
1221                 CIFSMaxBufSize = 8192;
1222         } else if (CIFSMaxBufSize > 1024*127) {
1223                 CIFSMaxBufSize = 1024 * 127;
1224         } else {
1225                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1226         }
1227 /*
1228         cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1229                  CIFSMaxBufSize, CIFSMaxBufSize);
1230 */
1231         cifs_req_cachep = kmem_cache_create("cifs_request",
1232                                             CIFSMaxBufSize + max_hdr_size, 0,
1233                                             SLAB_HWCACHE_ALIGN, NULL);
1234         if (cifs_req_cachep == NULL)
1235                 return -ENOMEM;
1236
1237         if (cifs_min_rcv < 1)
1238                 cifs_min_rcv = 1;
1239         else if (cifs_min_rcv > 64) {
1240                 cifs_min_rcv = 64;
1241                 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1242         }
1243
1244         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1245                                                   cifs_req_cachep);
1246
1247         if (cifs_req_poolp == NULL) {
1248                 kmem_cache_destroy(cifs_req_cachep);
1249                 return -ENOMEM;
1250         }
1251         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1252         almost all handle based requests (but not write response, nor is it
1253         sufficient for path based requests).  A smaller size would have
1254         been more efficient (compacting multiple slab items on one 4k page)
1255         for the case in which debug was on, but this larger size allows
1256         more SMBs to use small buffer alloc and is still much more
1257         efficient to alloc 1 per page off the slab compared to 17K (5page)
1258         alloc of large cifs buffers even when page debugging is on */
1259         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1260                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1261                         NULL);
1262         if (cifs_sm_req_cachep == NULL) {
1263                 mempool_destroy(cifs_req_poolp);
1264                 kmem_cache_destroy(cifs_req_cachep);
1265                 return -ENOMEM;
1266         }
1267
1268         if (cifs_min_small < 2)
1269                 cifs_min_small = 2;
1270         else if (cifs_min_small > 256) {
1271                 cifs_min_small = 256;
1272                 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1273         }
1274
1275         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1276                                                      cifs_sm_req_cachep);
1277
1278         if (cifs_sm_req_poolp == NULL) {
1279                 mempool_destroy(cifs_req_poolp);
1280                 kmem_cache_destroy(cifs_req_cachep);
1281                 kmem_cache_destroy(cifs_sm_req_cachep);
1282                 return -ENOMEM;
1283         }
1284
1285         return 0;
1286 }
1287
1288 static void
1289 cifs_destroy_request_bufs(void)
1290 {
1291         mempool_destroy(cifs_req_poolp);
1292         kmem_cache_destroy(cifs_req_cachep);
1293         mempool_destroy(cifs_sm_req_poolp);
1294         kmem_cache_destroy(cifs_sm_req_cachep);
1295 }
1296
1297 static int
1298 cifs_init_mids(void)
1299 {
1300         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1301                                             sizeof(struct mid_q_entry), 0,
1302                                             SLAB_HWCACHE_ALIGN, NULL);
1303         if (cifs_mid_cachep == NULL)
1304                 return -ENOMEM;
1305
1306         /* 3 is a reasonable minimum number of simultaneous operations */
1307         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1308         if (cifs_mid_poolp == NULL) {
1309                 kmem_cache_destroy(cifs_mid_cachep);
1310                 return -ENOMEM;
1311         }
1312
1313         return 0;
1314 }
1315
1316 static void
1317 cifs_destroy_mids(void)
1318 {
1319         mempool_destroy(cifs_mid_poolp);
1320         kmem_cache_destroy(cifs_mid_cachep);
1321 }
1322
1323 static int __init
1324 init_cifs(void)
1325 {
1326         int rc = 0;
1327         cifs_proc_init();
1328         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1329 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1330         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1331         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1332 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1333 /*
1334  *  Initialize Global counters
1335  */
1336         atomic_set(&sesInfoAllocCount, 0);
1337         atomic_set(&tconInfoAllocCount, 0);
1338         atomic_set(&tcpSesAllocCount, 0);
1339         atomic_set(&tcpSesReconnectCount, 0);
1340         atomic_set(&tconInfoReconnectCount, 0);
1341
1342         atomic_set(&bufAllocCount, 0);
1343         atomic_set(&smBufAllocCount, 0);
1344 #ifdef CONFIG_CIFS_STATS2
1345         atomic_set(&totBufAllocCount, 0);
1346         atomic_set(&totSmBufAllocCount, 0);
1347 #endif /* CONFIG_CIFS_STATS2 */
1348
1349         atomic_set(&midCount, 0);
1350         GlobalCurrentXid = 0;
1351         GlobalTotalActiveXid = 0;
1352         GlobalMaxActiveXid = 0;
1353         spin_lock_init(&cifs_tcp_ses_lock);
1354         spin_lock_init(&GlobalMid_Lock);
1355
1356         get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
1357
1358         if (cifs_max_pending < 2) {
1359                 cifs_max_pending = 2;
1360                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1361         } else if (cifs_max_pending > CIFS_MAX_REQ) {
1362                 cifs_max_pending = CIFS_MAX_REQ;
1363                 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1364                          CIFS_MAX_REQ);
1365         }
1366
1367         cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1368         if (!cifsiod_wq) {
1369                 rc = -ENOMEM;
1370                 goto out_clean_proc;
1371         }
1372
1373         rc = cifs_fscache_register();
1374         if (rc)
1375                 goto out_destroy_wq;
1376
1377         rc = cifs_init_inodecache();
1378         if (rc)
1379                 goto out_unreg_fscache;
1380
1381         rc = cifs_init_mids();
1382         if (rc)
1383                 goto out_destroy_inodecache;
1384
1385         rc = cifs_init_request_bufs();
1386         if (rc)
1387                 goto out_destroy_mids;
1388
1389 #ifdef CONFIG_CIFS_UPCALL
1390         rc = init_cifs_spnego();
1391         if (rc)
1392                 goto out_destroy_request_bufs;
1393 #endif /* CONFIG_CIFS_UPCALL */
1394
1395 #ifdef CONFIG_CIFS_ACL
1396         rc = init_cifs_idmap();
1397         if (rc)
1398                 goto out_register_key_type;
1399 #endif /* CONFIG_CIFS_ACL */
1400
1401         rc = register_filesystem(&cifs_fs_type);
1402         if (rc)
1403                 goto out_init_cifs_idmap;
1404
1405         return 0;
1406
1407 out_init_cifs_idmap:
1408 #ifdef CONFIG_CIFS_ACL
1409         exit_cifs_idmap();
1410 out_register_key_type:
1411 #endif
1412 #ifdef CONFIG_CIFS_UPCALL
1413         exit_cifs_spnego();
1414 out_destroy_request_bufs:
1415 #endif
1416         cifs_destroy_request_bufs();
1417 out_destroy_mids:
1418         cifs_destroy_mids();
1419 out_destroy_inodecache:
1420         cifs_destroy_inodecache();
1421 out_unreg_fscache:
1422         cifs_fscache_unregister();
1423 out_destroy_wq:
1424         destroy_workqueue(cifsiod_wq);
1425 out_clean_proc:
1426         cifs_proc_clean();
1427         return rc;
1428 }
1429
1430 static void __exit
1431 exit_cifs(void)
1432 {
1433         cifs_dbg(NOISY, "exit_cifs\n");
1434         unregister_filesystem(&cifs_fs_type);
1435         cifs_dfs_release_automount_timer();
1436 #ifdef CONFIG_CIFS_ACL
1437         exit_cifs_idmap();
1438 #endif
1439 #ifdef CONFIG_CIFS_UPCALL
1440         unregister_key_type(&cifs_spnego_key_type);
1441 #endif
1442         cifs_destroy_request_bufs();
1443         cifs_destroy_mids();
1444         cifs_destroy_inodecache();
1445         cifs_fscache_unregister();
1446         destroy_workqueue(cifsiod_wq);
1447         cifs_proc_clean();
1448 }
1449
1450 MODULE_AUTHOR("Steve French <[email protected]>");
1451 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1452 MODULE_DESCRIPTION
1453     ("VFS to access servers complying with the SNIA CIFS Specification "
1454      "e.g. Samba and Windows");
1455 MODULE_VERSION(CIFS_VERSION);
1456 MODULE_SOFTDEP("pre: arc4");
1457 MODULE_SOFTDEP("pre: des");
1458 MODULE_SOFTDEP("pre: ecb");
1459 MODULE_SOFTDEP("pre: hmac");
1460 MODULE_SOFTDEP("pre: md4");
1461 MODULE_SOFTDEP("pre: md5");
1462 MODULE_SOFTDEP("pre: nls");
1463 #ifdef CONFIG_CIFS_SMB2
1464 MODULE_SOFTDEP("pre: aes");
1465 MODULE_SOFTDEP("pre: cmac");
1466 MODULE_SOFTDEP("pre: sha256");
1467 MODULE_SOFTDEP("pre: aead2");
1468 MODULE_SOFTDEP("pre: ccm");
1469 #endif /* CONFIG_CIFS_SMB2 */
1470 module_init(init_cifs)
1471 module_exit(exit_cifs)