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