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 <net/ipv6.h>
  39 #include "cifsfs.h"
  40 #include "cifspdu.h"
  41 #define DECLARE_GLOBALS_HERE
  42 #include "cifsglob.h"
  43 #include "cifsproto.h"
  44 #include "cifs_debug.h"
  45 #include "cifs_fs_sb.h"
  46 #include <linux/mm.h>
  47 #include <linux/key-type.h>
  48 #include "cifs_spnego.h"
  49 #include "fscache.h"
  50 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
  51
  52 int cifsFYI = 0;
  53 int cifsERROR = 1;
  54 int traceSMB = 0;
  55 unsigned int oplockEnabled = 1;
  56 unsigned int linuxExtEnabled = 1;
  57 unsigned int lookupCacheEnabled = 1;
  58 unsigned int multiuser_mount = 0;
  59 unsigned int global_secflags = CIFSSEC_DEF;
  60 /* unsigned int ntlmv2_support = 0; */
  61 unsigned int sign_CIFS_PDUs = 1;
  62 static const struct super_operations cifs_super_ops;
  63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  64 module_param(CIFSMaxBufSize, int, 0);
  65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
  66                                  "Default: 16384 Range: 8192 to 130048");
  67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  68 module_param(cifs_min_rcv, int, 0);
  69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  70                                 "1 to 64");
  71 unsigned int cifs_min_small = 30;
  72 module_param(cifs_min_small, int, 0);
  73 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  74                                  "Range: 2 to 256");
  75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  76 module_param(cifs_max_pending, int, 0);
  77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  78                                    "Default: 50 Range: 2 to 256");
  79 unsigned short echo_retries = 5;
  80 module_param(echo_retries, ushort, 0644);
  81 MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
  82                                "reconnecting server. Default: 5. 0 means "
  83                                "never reconnect.");
  84 extern mempool_t *cifs_sm_req_poolp;
  85 extern mempool_t *cifs_req_poolp;
  86 extern mempool_t *cifs_mid_poolp;
  87
  88 void
  89 cifs_sb_active(struct super_block *sb)
  90 {
  91         struct cifs_sb_info *server = CIFS_SB(sb);
  92
  93         if (atomic_inc_return(&server->active) == 1)
  94                 atomic_inc(&sb->s_active);
  95 }
  96
  97 void
  98 cifs_sb_deactive(struct super_block *sb)
  99 {
 100         struct cifs_sb_info *server = CIFS_SB(sb);
 101
 102         if (atomic_dec_and_test(&server->active))
 103                 deactivate_super(sb);
 104 }
 105
 106 static int
 107 cifs_read_super(struct super_block *sb, struct cifs_sb_info *cifs_sb,
 108                 void *data, struct smb_vol *volume_info, const char *devname,
 109                 int silent)
 110 {
 111         struct inode *inode;
 112         int rc = 0;
 113
 114         /* BB should we make this contingent on mount parm? */
 115         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
 116         sb->s_fs_info = cifs_sb;
 117
 118         spin_lock_init(&cifs_sb->tlink_tree_lock);
 119         cifs_sb->tlink_tree = RB_ROOT;
 120
 121         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
 122         if (rc) {
 123                 kfree(cifs_sb);
 124                 return rc;
 125         }
 126         cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
 127
 128         if (data)
 129                 cifs_sb->mountdata = data;
 130
 131         rc = cifs_mount(sb, cifs_sb, volume_info, devname);
 132
 133         if (rc) {
 134                 if (!silent)
 135                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
 136                 goto out_mount_failed;
 137         }
 138
 139         sb->s_magic = CIFS_MAGIC_NUMBER;
 140         sb->s_op = &cifs_super_ops;
 141         sb->s_bdi = &cifs_sb->bdi;
 142         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 143         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 144         inode = cifs_root_iget(sb);
 145
 146         if (IS_ERR(inode)) {
 147                 rc = PTR_ERR(inode);
 148                 inode = NULL;
 149                 goto out_no_root;
 150         }
 151
 152         sb->s_root = d_alloc_root(inode);
 153
 154         if (!sb->s_root) {
 155                 rc = -ENOMEM;
 156                 goto out_no_root;
 157         }
 158
 159         /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
 160         if (cifs_sb_master_tcon(cifs_sb)->nocase)
 161                 sb->s_d_op = &cifs_ci_dentry_ops;
 162         else
 163                 sb->s_d_op = &cifs_dentry_ops;
 164
 165 #ifdef CIFS_NFSD_EXPORT
 166         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 167                 cFYI(1, "export ops supported");
 168                 sb->s_export_op = &cifs_export_ops;
 169         }
 170 #endif /* CIFS_NFSD_EXPORT */
 171
 172         return 0;
 173
 174 out_no_root:
 175         cERROR(1, "cifs_read_super: get root inode failed");
 176         if (inode)
 177                 iput(inode);
 178
 179         cifs_umount(sb, cifs_sb);
 180
 181 out_mount_failed:
 182         if (cifs_sb) {
 183                 if (cifs_sb->mountdata) {
 184                         kfree(cifs_sb->mountdata);
 185                         cifs_sb->mountdata = NULL;
 186                 }
 187                 unload_nls(cifs_sb->local_nls);
 188                 bdi_destroy(&cifs_sb->bdi);
 189                 kfree(cifs_sb);
 190         }
 191         return rc;
 192 }
 193
 194 static void
 195 cifs_put_super(struct super_block *sb)
 196 {
 197         int rc = 0;
 198         struct cifs_sb_info *cifs_sb;
 199
 200         cFYI(1, "In cifs_put_super");
 201         cifs_sb = CIFS_SB(sb);
 202         if (cifs_sb == NULL) {
 203                 cFYI(1, "Empty cifs superblock info passed to unmount");
 204                 return;
 205         }
 206
 207         rc = cifs_umount(sb, cifs_sb);
 208         if (rc)
 209                 cERROR(1, "cifs_umount failed with return code %d", rc);
 210         if (cifs_sb->mountdata) {
 211                 kfree(cifs_sb->mountdata);
 212                 cifs_sb->mountdata = NULL;
 213         }
 214
 215         unload_nls(cifs_sb->local_nls);
 216         bdi_destroy(&cifs_sb->bdi);
 217         kfree(cifs_sb);
 218 }
 219
 220 static int
 221 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 222 {
 223         struct super_block *sb = dentry->d_sb;
 224         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 225         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
 226         int rc = -EOPNOTSUPP;
 227         int xid;
 228
 229         xid = GetXid();
 230
 231         buf->f_type = CIFS_MAGIC_NUMBER;
 232
 233         /*
 234          * PATH_MAX may be too long - it would presumably be total path,
 235          * but note that some servers (includinng Samba 3) have a shorter
 236          * maximum path.
 237          *
 238          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
 239          */
 240         buf->f_namelen = PATH_MAX;
 241         buf->f_files = 0;       /* undefined */
 242         buf->f_ffree = 0;       /* unlimited */
 243
 244         /*
 245          * We could add a second check for a QFS Unix capability bit
 246          */
 247         if ((tcon->ses->capabilities & CAP_UNIX) &&
 248             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
 249                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
 250
 251         /*
 252          * Only need to call the old QFSInfo if failed on newer one,
 253          * e.g. by OS/2.
 254          **/
 255         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
 256                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
 257
 258         /*
 259          * Some old Windows servers also do not support level 103, retry with
 260          * older level one if old server failed the previous call or we
 261          * bypassed it because we detected that this was an older LANMAN sess
 262          */
 263         if (rc)
 264                 rc = SMBOldQFSInfo(xid, tcon, buf);
 265
 266         FreeXid(xid);
 267         return 0;
 268 }
 269
 270 static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
 271 {
 272         struct cifs_sb_info *cifs_sb;
 273
 274         if (flags & IPERM_FLAG_RCU)
 275                 return -ECHILD;
 276
 277         cifs_sb = CIFS_SB(inode->i_sb);
 278
 279         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 280                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 281                         return -EACCES;
 282                 else
 283                         return 0;
 284         } else /* file mode might have been restricted at mount time
 285                 on the client (above and beyond ACL on servers) for
 286                 servers which do not support setting and viewing mode bits,
 287                 so allowing client to check permissions is useful */
 288                 return generic_permission(inode, mask, flags, NULL);
 289 }
 290
 291 static struct kmem_cache *cifs_inode_cachep;
 292 static struct kmem_cache *cifs_req_cachep;
 293 static struct kmem_cache *cifs_mid_cachep;
 294 static struct kmem_cache *cifs_sm_req_cachep;
 295 mempool_t *cifs_sm_req_poolp;
 296 mempool_t *cifs_req_poolp;
 297 mempool_t *cifs_mid_poolp;
 298
 299 static struct inode *
 300 cifs_alloc_inode(struct super_block *sb)
 301 {
 302         struct cifsInodeInfo *cifs_inode;
 303         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 304         if (!cifs_inode)
 305                 return NULL;
 306         cifs_inode->cifsAttrs = 0x20;   /* default */
 307         cifs_inode->time = 0;
 308         /* Until the file is open and we have gotten oplock
 309         info back from the server, can not assume caching of
 310         file data or metadata */
 311         cifs_set_oplock_level(cifs_inode, 0);
 312         cifs_inode->delete_pending = false;
 313         cifs_inode->invalid_mapping = false;
 314         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 315         cifs_inode->server_eof = 0;
 316         cifs_inode->uniqueid = 0;
 317         cifs_inode->createtime = 0;
 318
 319         /* Can not set i_flags here - they get immediately overwritten
 320            to zero by the VFS */
 321 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
 322         INIT_LIST_HEAD(&cifs_inode->openFileList);
 323         return &cifs_inode->vfs_inode;
 324 }
 325
 326 static void cifs_i_callback(struct rcu_head *head)
 327 {
 328         struct inode *inode = container_of(head, struct inode, i_rcu);
 329         INIT_LIST_HEAD(&inode->i_dentry);
 330         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 331 }
 332
 333 static void
 334 cifs_destroy_inode(struct inode *inode)
 335 {
 336         call_rcu(&inode->i_rcu, cifs_i_callback);
 337 }
 338
 339 static void
 340 cifs_evict_inode(struct inode *inode)
 341 {
 342         truncate_inode_pages(&inode->i_data, 0);
 343         end_writeback(inode);
 344         cifs_fscache_release_inode_cookie(inode);
 345 }
 346
 347 static void
 348 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 349 {
 350         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 351         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 352
 353         seq_printf(s, ",addr=");
 354
 355         switch (server->dstaddr.ss_family) {
 356         case AF_INET:
 357                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 358                 break;
 359         case AF_INET6:
 360                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 361                 if (sa6->sin6_scope_id)
 362                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
 363                 break;
 364         default:
 365                 seq_printf(s, "(unknown)");
 366         }
 367 }
 368
 369 /*
 370  * cifs_show_options() is for displaying mount options in /proc/mounts.
 371  * Not all settable options are displayed but most of the important
 372  * ones are.
 373  */
 374 static int
 375 cifs_show_options(struct seq_file *s, struct vfsmount *m)
 376 {
 377         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
 378         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
 379         struct sockaddr *srcaddr;
 380         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 381
 382         seq_printf(s, ",unc=%s", tcon->treeName);
 383
 384         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 385                 seq_printf(s, ",multiuser");
 386         else if (tcon->ses->user_name)
 387                 seq_printf(s, ",username=%s", tcon->ses->user_name);
 388
 389         if (tcon->ses->domainName)
 390                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
 391
 392         if (srcaddr->sa_family != AF_UNSPEC) {
 393                 struct sockaddr_in *saddr4;
 394                 struct sockaddr_in6 *saddr6;
 395                 saddr4 = (struct sockaddr_in *)srcaddr;
 396                 saddr6 = (struct sockaddr_in6 *)srcaddr;
 397                 if (srcaddr->sa_family == AF_INET6)
 398                         seq_printf(s, ",srcaddr=%pI6c",
 399                                    &saddr6->sin6_addr);
 400                 else if (srcaddr->sa_family == AF_INET)
 401                         seq_printf(s, ",srcaddr=%pI4",
 402                                    &saddr4->sin_addr.s_addr);
 403                 else
 404                         seq_printf(s, ",srcaddr=BAD-AF:%i",
 405                                    (int)(srcaddr->sa_family));
 406         }
 407
 408         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
 409         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 410                 seq_printf(s, ",forceuid");
 411         else
 412                 seq_printf(s, ",noforceuid");
 413
 414         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
 415         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 416                 seq_printf(s, ",forcegid");
 417         else
 418                 seq_printf(s, ",noforcegid");
 419
 420         cifs_show_address(s, tcon->ses->server);
 421
 422         if (!tcon->unix_ext)
 423                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
 424                                            cifs_sb->mnt_file_mode,
 425                                            cifs_sb->mnt_dir_mode);
 426         if (tcon->seal)
 427                 seq_printf(s, ",seal");
 428         if (tcon->nocase)
 429                 seq_printf(s, ",nocase");
 430         if (tcon->retry)
 431                 seq_printf(s, ",hard");
 432         if (cifs_sb->prepath)
 433                 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
 434         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 435                 seq_printf(s, ",posixpaths");
 436         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 437                 seq_printf(s, ",setuids");
 438         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 439                 seq_printf(s, ",serverino");
 440         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 441                 seq_printf(s, ",directio");
 442         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 443                 seq_printf(s, ",nouser_xattr");
 444         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 445                 seq_printf(s, ",mapchars");
 446         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 447                 seq_printf(s, ",sfu");
 448         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 449                 seq_printf(s, ",nobrl");
 450         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 451                 seq_printf(s, ",cifsacl");
 452         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 453                 seq_printf(s, ",dynperm");
 454         if (m->mnt_sb->s_flags & MS_POSIXACL)
 455                 seq_printf(s, ",acl");
 456         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 457                 seq_printf(s, ",mfsymlinks");
 458         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 459                 seq_printf(s, ",fsc");
 460
 461         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
 462         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
 463         /* convert actimeo and display it in seconds */
 464                 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 465
 466         return 0;
 467 }
 468
 469 static void cifs_umount_begin(struct super_block *sb)
 470 {
 471         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 472         struct cifsTconInfo *tcon;
 473
 474         if (cifs_sb == NULL)
 475                 return;
 476
 477         tcon = cifs_sb_master_tcon(cifs_sb);
 478
 479         spin_lock(&cifs_tcp_ses_lock);
 480         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 481                 /* we have other mounts to same share or we have
 482                    already tried to force umount this and woken up
 483                    all waiting network requests, nothing to do */
 484                 spin_unlock(&cifs_tcp_ses_lock);
 485                 return;
 486         } else if (tcon->tc_count == 1)
 487                 tcon->tidStatus = CifsExiting;
 488         spin_unlock(&cifs_tcp_ses_lock);
 489
 490         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 491         /* cancel_notify_requests(tcon); */
 492         if (tcon->ses && tcon->ses->server) {
 493                 cFYI(1, "wake up tasks now - umount begin not complete");
 494                 wake_up_all(&tcon->ses->server->request_q);
 495                 wake_up_all(&tcon->ses->server->response_q);
 496                 msleep(1); /* yield */
 497                 /* we have to kick the requests once more */
 498                 wake_up_all(&tcon->ses->server->response_q);
 499                 msleep(1);
 500         }
 501
 502         return;
 503 }
 504
 505 #ifdef CONFIG_CIFS_STATS2
 506 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 507 {
 508         /* BB FIXME */
 509         return 0;
 510 }
 511 #endif
 512
 513 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 514 {
 515         *flags |= MS_NODIRATIME;
 516         return 0;
 517 }
 518
 519 static int cifs_drop_inode(struct inode *inode)
 520 {
 521         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 522
 523         /* no serverino => unconditional eviction */
 524         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 525                 generic_drop_inode(inode);
 526 }
 527
 528 static const struct super_operations cifs_super_ops = {
 529         .put_super = cifs_put_super,
 530         .statfs = cifs_statfs,
 531         .alloc_inode = cifs_alloc_inode,
 532         .destroy_inode = cifs_destroy_inode,
 533         .drop_inode     = cifs_drop_inode,
 534         .evict_inode    = cifs_evict_inode,
 535 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 536         function unless later we add lazy close of inodes or unless the
 537         kernel forgets to call us with the same number of releases (closes)
 538         as opens */
 539         .show_options = cifs_show_options,
 540         .umount_begin   = cifs_umount_begin,
 541         .remount_fs = cifs_remount,
 542 #ifdef CONFIG_CIFS_STATS2
 543         .show_stats = cifs_show_stats,
 544 #endif
 545 };
 546
 547 static struct dentry *
 548 cifs_do_mount(struct file_system_type *fs_type,
 549               int flags, const char *dev_name, void *data)
 550 {
 551         int rc;
 552         struct super_block *sb;
 553         struct cifs_sb_info *cifs_sb;
 554         struct smb_vol *volume_info;
 555         struct dentry *root;
 556         char *copied_data = NULL;
 557
 558         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
 559
 560         rc = cifs_setup_volume_info(&volume_info, (char *)data, dev_name);
 561         if (rc)
 562                 return ERR_PTR(rc);
 563
 564         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 565         if (cifs_sb == NULL) {
 566                 root = ERR_PTR(-ENOMEM);
 567                 goto out;
 568         }
 569
 570         cifs_setup_cifs_sb(volume_info, cifs_sb);
 571
 572         sb = sget(fs_type, NULL, set_anon_super, NULL);
 573         if (IS_ERR(sb)) {
 574                 kfree(cifs_sb);
 575                 root = ERR_CAST(sb);
 576                 goto out;
 577         }
 578
 579         sb->s_flags = flags;
 580
 581         /*
 582          * Copy mount params for use in submounts. Better to do
 583          * the copy here and deal with the error before cleanup gets
 584          * complicated post-mount.
 585          */
 586         copied_data = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 587         if (copied_data == NULL) {
 588                 root = ERR_PTR(-ENOMEM);
 589                 goto err_out;
 590         }
 591
 592         rc = cifs_read_super(sb, cifs_sb, copied_data, volume_info, dev_name,
 593                              flags & MS_SILENT ? 1 : 0);
 594         if (rc) {
 595                 root = ERR_PTR(rc);
 596                 goto err_out;
 597         }
 598
 599         sb->s_flags |= MS_ACTIVE;
 600
 601         root = dget(sb->s_root);
 602 out:
 603         cifs_cleanup_volume_info(&volume_info);
 604         return root;
 605
 606 err_out:
 607         kfree(cifs_sb);
 608         deactivate_locked_super(sb);
 609         cifs_cleanup_volume_info(&volume_info);
 610         return root;
 611 }
 612
 613 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 614                                    unsigned long nr_segs, loff_t pos)
 615 {
 616         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 617         ssize_t written;
 618         int rc;
 619
 620         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
 621
 622         if (CIFS_I(inode)->clientCanCacheAll)
 623                 return written;
 624
 625         rc = filemap_fdatawrite(inode->i_mapping);
 626         if (rc)
 627                 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
 628
 629         return written;
 630 }
 631
 632 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 633 {
 634         /* origin == SEEK_END => we must revalidate the cached file length */
 635         if (origin == SEEK_END) {
 636                 int rc;
 637                 struct inode *inode = file->f_path.dentry->d_inode;
 638
 639                 /*
 640                  * We need to be sure that all dirty pages are written and the
 641                  * server has the newest file length.
 642                  */
 643                 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
 644                     inode->i_mapping->nrpages != 0) {
 645                         rc = filemap_fdatawait(inode->i_mapping);
 646                         if (rc) {
 647                                 mapping_set_error(inode->i_mapping, rc);
 648                                 return rc;
 649                         }
 650                 }
 651                 /*
 652                  * Some applications poll for the file length in this strange
 653                  * way so we must seek to end on non-oplocked files by
 654                  * setting the revalidate time to zero.
 655                  */
 656                 CIFS_I(inode)->time = 0;
 657
 658                 rc = cifs_revalidate_file_attr(file);
 659                 if (rc < 0)
 660                         return (loff_t)rc;
 661         }
 662         return generic_file_llseek_unlocked(file, offset, origin);
 663 }
 664
 665 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
 666 {
 667         /* note that this is called by vfs setlease with lock_flocks held
 668            to protect *lease from going away */
 669         struct inode *inode = file->f_path.dentry->d_inode;
 670         struct cifsFileInfo *cfile = file->private_data;
 671
 672         if (!(S_ISREG(inode->i_mode)))
 673                 return -EINVAL;
 674
 675         /* check if file is oplocked */
 676         if (((arg == F_RDLCK) &&
 677                 (CIFS_I(inode)->clientCanCacheRead)) ||
 678             ((arg == F_WRLCK) &&
 679                 (CIFS_I(inode)->clientCanCacheAll)))
 680                 return generic_setlease(file, arg, lease);
 681         else if (tlink_tcon(cfile->tlink)->local_lease &&
 682                  !CIFS_I(inode)->clientCanCacheRead)
 683                 /* If the server claims to support oplock on this
 684                    file, then we still need to check oplock even
 685                    if the local_lease mount option is set, but there
 686                    are servers which do not support oplock for which
 687                    this mount option may be useful if the user
 688                    knows that the file won't be changed on the server
 689                    by anyone else */
 690                 return generic_setlease(file, arg, lease);
 691         else
 692                 return -EAGAIN;
 693 }
 694
 695 struct file_system_type cifs_fs_type = {
 696         .owner = THIS_MODULE,
 697         .name = "cifs",
 698         .mount = cifs_do_mount,
 699         .kill_sb = kill_anon_super,
 700         /*  .fs_flags */
 701 };
 702 const struct inode_operations cifs_dir_inode_ops = {
 703         .create = cifs_create,
 704         .lookup = cifs_lookup,
 705         .getattr = cifs_getattr,
 706         .unlink = cifs_unlink,
 707         .link = cifs_hardlink,
 708         .mkdir = cifs_mkdir,
 709         .rmdir = cifs_rmdir,
 710         .rename = cifs_rename,
 711         .permission = cifs_permission,
 712 /*      revalidate:cifs_revalidate,   */
 713         .setattr = cifs_setattr,
 714         .symlink = cifs_symlink,
 715         .mknod   = cifs_mknod,
 716 #ifdef CONFIG_CIFS_XATTR
 717         .setxattr = cifs_setxattr,
 718         .getxattr = cifs_getxattr,
 719         .listxattr = cifs_listxattr,
 720         .removexattr = cifs_removexattr,
 721 #endif
 722 };
 723
 724 const struct inode_operations cifs_file_inode_ops = {
 725 /*      revalidate:cifs_revalidate, */
 726         .setattr = cifs_setattr,
 727         .getattr = cifs_getattr, /* do we need this anymore? */
 728         .rename = cifs_rename,
 729         .permission = cifs_permission,
 730 #ifdef CONFIG_CIFS_XATTR
 731         .setxattr = cifs_setxattr,
 732         .getxattr = cifs_getxattr,
 733         .listxattr = cifs_listxattr,
 734         .removexattr = cifs_removexattr,
 735 #endif
 736 };
 737
 738 const struct inode_operations cifs_symlink_inode_ops = {
 739         .readlink = generic_readlink,
 740         .follow_link = cifs_follow_link,
 741         .put_link = cifs_put_link,
 742         .permission = cifs_permission,
 743         /* BB add the following two eventually */
 744         /* revalidate: cifs_revalidate,
 745            setattr:    cifs_notify_change, *//* BB do we need notify change */
 746 #ifdef CONFIG_CIFS_XATTR
 747         .setxattr = cifs_setxattr,
 748         .getxattr = cifs_getxattr,
 749         .listxattr = cifs_listxattr,
 750         .removexattr = cifs_removexattr,
 751 #endif
 752 };
 753
 754 const struct file_operations cifs_file_ops = {
 755         .read = do_sync_read,
 756         .write = do_sync_write,
 757         .aio_read = generic_file_aio_read,
 758         .aio_write = cifs_file_aio_write,
 759         .open = cifs_open,
 760         .release = cifs_close,
 761         .lock = cifs_lock,
 762         .fsync = cifs_fsync,
 763         .flush = cifs_flush,
 764         .mmap  = cifs_file_mmap,
 765         .splice_read = generic_file_splice_read,
 766         .llseek = cifs_llseek,
 767 #ifdef CONFIG_CIFS_POSIX
 768         .unlocked_ioctl = cifs_ioctl,
 769 #endif /* CONFIG_CIFS_POSIX */
 770         .setlease = cifs_setlease,
 771 };
 772
 773 const struct file_operations cifs_file_strict_ops = {
 774         .read = do_sync_read,
 775         .write = do_sync_write,
 776         .aio_read = cifs_strict_readv,
 777         .aio_write = cifs_strict_writev,
 778         .open = cifs_open,
 779         .release = cifs_close,
 780         .lock = cifs_lock,
 781         .fsync = cifs_strict_fsync,
 782         .flush = cifs_flush,
 783         .mmap = cifs_file_strict_mmap,
 784         .splice_read = generic_file_splice_read,
 785         .llseek = cifs_llseek,
 786 #ifdef CONFIG_CIFS_POSIX
 787         .unlocked_ioctl = cifs_ioctl,
 788 #endif /* CONFIG_CIFS_POSIX */
 789         .setlease = cifs_setlease,
 790 };
 791
 792 const struct file_operations cifs_file_direct_ops = {
 793         /* BB reevaluate whether they can be done with directio, no cache */
 794         .read = do_sync_read,
 795         .write = do_sync_write,
 796         .aio_read = cifs_user_readv,
 797         .aio_write = cifs_user_writev,
 798         .open = cifs_open,
 799         .release = cifs_close,
 800         .lock = cifs_lock,
 801         .fsync = cifs_fsync,
 802         .flush = cifs_flush,
 803         .mmap = cifs_file_mmap,
 804         .splice_read = generic_file_splice_read,
 805 #ifdef CONFIG_CIFS_POSIX
 806         .unlocked_ioctl  = cifs_ioctl,
 807 #endif /* CONFIG_CIFS_POSIX */
 808         .llseek = cifs_llseek,
 809         .setlease = cifs_setlease,
 810 };
 811
 812 const struct file_operations cifs_file_nobrl_ops = {
 813         .read = do_sync_read,
 814         .write = do_sync_write,
 815         .aio_read = generic_file_aio_read,
 816         .aio_write = cifs_file_aio_write,
 817         .open = cifs_open,
 818         .release = cifs_close,
 819         .fsync = cifs_fsync,
 820         .flush = cifs_flush,
 821         .mmap  = cifs_file_mmap,
 822         .splice_read = generic_file_splice_read,
 823         .llseek = cifs_llseek,
 824 #ifdef CONFIG_CIFS_POSIX
 825         .unlocked_ioctl = cifs_ioctl,
 826 #endif /* CONFIG_CIFS_POSIX */
 827         .setlease = cifs_setlease,
 828 };
 829
 830 const struct file_operations cifs_file_strict_nobrl_ops = {
 831         .read = do_sync_read,
 832         .write = do_sync_write,
 833         .aio_read = cifs_strict_readv,
 834         .aio_write = cifs_strict_writev,
 835         .open = cifs_open,
 836         .release = cifs_close,
 837         .fsync = cifs_strict_fsync,
 838         .flush = cifs_flush,
 839         .mmap = cifs_file_strict_mmap,
 840         .splice_read = generic_file_splice_read,
 841         .llseek = cifs_llseek,
 842 #ifdef CONFIG_CIFS_POSIX
 843         .unlocked_ioctl = cifs_ioctl,
 844 #endif /* CONFIG_CIFS_POSIX */
 845         .setlease = cifs_setlease,
 846 };
 847
 848 const struct file_operations cifs_file_direct_nobrl_ops = {
 849         /* BB reevaluate whether they can be done with directio, no cache */
 850         .read = do_sync_read,
 851         .write = do_sync_write,
 852         .aio_read = cifs_user_readv,
 853         .aio_write = cifs_user_writev,
 854         .open = cifs_open,
 855         .release = cifs_close,
 856         .fsync = cifs_fsync,
 857         .flush = cifs_flush,
 858         .mmap = cifs_file_mmap,
 859         .splice_read = generic_file_splice_read,
 860 #ifdef CONFIG_CIFS_POSIX
 861         .unlocked_ioctl  = cifs_ioctl,
 862 #endif /* CONFIG_CIFS_POSIX */
 863         .llseek = cifs_llseek,
 864         .setlease = cifs_setlease,
 865 };
 866
 867 const struct file_operations cifs_dir_ops = {
 868         .readdir = cifs_readdir,
 869         .release = cifs_closedir,
 870         .read    = generic_read_dir,
 871         .unlocked_ioctl  = cifs_ioctl,
 872         .llseek = generic_file_llseek,
 873 };
 874
 875 static void
 876 cifs_init_once(void *inode)
 877 {
 878         struct cifsInodeInfo *cifsi = inode;
 879
 880         inode_init_once(&cifsi->vfs_inode);
 881         INIT_LIST_HEAD(&cifsi->lockList);
 882 }
 883
 884 static int
 885 cifs_init_inodecache(void)
 886 {
 887         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 888                                               sizeof(struct cifsInodeInfo),
 889                                               0, (SLAB_RECLAIM_ACCOUNT|
 890                                                 SLAB_MEM_SPREAD),
 891                                               cifs_init_once);
 892         if (cifs_inode_cachep == NULL)
 893                 return -ENOMEM;
 894
 895         return 0;
 896 }
 897
 898 static void
 899 cifs_destroy_inodecache(void)
 900 {
 901         kmem_cache_destroy(cifs_inode_cachep);
 902 }
 903
 904 static int
 905 cifs_init_request_bufs(void)
 906 {
 907         if (CIFSMaxBufSize < 8192) {
 908         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 909         Unicode path name has to fit in any SMB/CIFS path based frames */
 910                 CIFSMaxBufSize = 8192;
 911         } else if (CIFSMaxBufSize > 1024*127) {
 912                 CIFSMaxBufSize = 1024 * 127;
 913         } else {
 914                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 915         }
 916 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
 917         cifs_req_cachep = kmem_cache_create("cifs_request",
 918                                             CIFSMaxBufSize +
 919                                             MAX_CIFS_HDR_SIZE, 0,
 920                                             SLAB_HWCACHE_ALIGN, NULL);
 921         if (cifs_req_cachep == NULL)
 922                 return -ENOMEM;
 923
 924         if (cifs_min_rcv < 1)
 925                 cifs_min_rcv = 1;
 926         else if (cifs_min_rcv > 64) {
 927                 cifs_min_rcv = 64;
 928                 cERROR(1, "cifs_min_rcv set to maximum (64)");
 929         }
 930
 931         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 932                                                   cifs_req_cachep);
 933
 934         if (cifs_req_poolp == NULL) {
 935                 kmem_cache_destroy(cifs_req_cachep);
 936                 return -ENOMEM;
 937         }
 938         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 939         almost all handle based requests (but not write response, nor is it
 940         sufficient for path based requests).  A smaller size would have
 941         been more efficient (compacting multiple slab items on one 4k page)
 942         for the case in which debug was on, but this larger size allows
 943         more SMBs to use small buffer alloc and is still much more
 944         efficient to alloc 1 per page off the slab compared to 17K (5page)
 945         alloc of large cifs buffers even when page debugging is on */
 946         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 947                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 948                         NULL);
 949         if (cifs_sm_req_cachep == NULL) {
 950                 mempool_destroy(cifs_req_poolp);
 951                 kmem_cache_destroy(cifs_req_cachep);
 952                 return -ENOMEM;
 953         }
 954
 955         if (cifs_min_small < 2)
 956                 cifs_min_small = 2;
 957         else if (cifs_min_small > 256) {
 958                 cifs_min_small = 256;
 959                 cFYI(1, "cifs_min_small set to maximum (256)");
 960         }
 961
 962         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 963                                                      cifs_sm_req_cachep);
 964
 965         if (cifs_sm_req_poolp == NULL) {
 966                 mempool_destroy(cifs_req_poolp);
 967                 kmem_cache_destroy(cifs_req_cachep);
 968                 kmem_cache_destroy(cifs_sm_req_cachep);
 969                 return -ENOMEM;
 970         }
 971
 972         return 0;
 973 }
 974
 975 static void
 976 cifs_destroy_request_bufs(void)
 977 {
 978         mempool_destroy(cifs_req_poolp);
 979         kmem_cache_destroy(cifs_req_cachep);
 980         mempool_destroy(cifs_sm_req_poolp);
 981         kmem_cache_destroy(cifs_sm_req_cachep);
 982 }
 983
 984 static int
 985 cifs_init_mids(void)
 986 {
 987         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 988                                             sizeof(struct mid_q_entry), 0,
 989                                             SLAB_HWCACHE_ALIGN, NULL);
 990         if (cifs_mid_cachep == NULL)
 991                 return -ENOMEM;
 992
 993         /* 3 is a reasonable minimum number of simultaneous operations */
 994         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 995         if (cifs_mid_poolp == NULL) {
 996                 kmem_cache_destroy(cifs_mid_cachep);
 997                 return -ENOMEM;
 998         }
 999
1000         return 0;
1001 }
1002
1003 static void
1004 cifs_destroy_mids(void)
1005 {
1006         mempool_destroy(cifs_mid_poolp);
1007         kmem_cache_destroy(cifs_mid_cachep);
1008 }
1009
1010 static int __init
1011 init_cifs(void)
1012 {
1013         int rc = 0;
1014         cifs_proc_init();
1015         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1016 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1017         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1018         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1019 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1020 /*
1021  *  Initialize Global counters
1022  */
1023         atomic_set(&sesInfoAllocCount, 0);
1024         atomic_set(&tconInfoAllocCount, 0);
1025         atomic_set(&tcpSesAllocCount, 0);
1026         atomic_set(&tcpSesReconnectCount, 0);
1027         atomic_set(&tconInfoReconnectCount, 0);
1028
1029         atomic_set(&bufAllocCount, 0);
1030         atomic_set(&smBufAllocCount, 0);
1031 #ifdef CONFIG_CIFS_STATS2
1032         atomic_set(&totBufAllocCount, 0);
1033         atomic_set(&totSmBufAllocCount, 0);
1034 #endif /* CONFIG_CIFS_STATS2 */
1035
1036         atomic_set(&midCount, 0);
1037         GlobalCurrentXid = 0;
1038         GlobalTotalActiveXid = 0;
1039         GlobalMaxActiveXid = 0;
1040         spin_lock_init(&cifs_tcp_ses_lock);
1041         spin_lock_init(&cifs_file_list_lock);
1042         spin_lock_init(&GlobalMid_Lock);
1043
1044         if (cifs_max_pending < 2) {
1045                 cifs_max_pending = 2;
1046                 cFYI(1, "cifs_max_pending set to min of 2");
1047         } else if (cifs_max_pending > 256) {
1048                 cifs_max_pending = 256;
1049                 cFYI(1, "cifs_max_pending set to max of 256");
1050         }
1051
1052         rc = cifs_fscache_register();
1053         if (rc)
1054                 goto out_clean_proc;
1055
1056         rc = cifs_init_inodecache();
1057         if (rc)
1058                 goto out_unreg_fscache;
1059
1060         rc = cifs_init_mids();
1061         if (rc)
1062                 goto out_destroy_inodecache;
1063
1064         rc = cifs_init_request_bufs();
1065         if (rc)
1066                 goto out_destroy_mids;
1067
1068 #ifdef CONFIG_CIFS_UPCALL
1069         rc = register_key_type(&cifs_spnego_key_type);
1070         if (rc)
1071                 goto out_destroy_request_bufs;
1072 #endif /* CONFIG_CIFS_UPCALL */
1073
1074 #ifdef CONFIG_CIFS_ACL
1075         rc = init_cifs_idmap();
1076         if (rc)
1077                 goto out_register_key_type;
1078 #endif /* CONFIG_CIFS_ACL */
1079
1080         rc = register_filesystem(&cifs_fs_type);
1081         if (rc)
1082                 goto out_init_cifs_idmap;
1083
1084         return 0;
1085
1086 out_init_cifs_idmap:
1087 #ifdef CONFIG_CIFS_ACL
1088         exit_cifs_idmap();
1089 out_register_key_type:
1090 #endif
1091 #ifdef CONFIG_CIFS_UPCALL
1092         unregister_key_type(&cifs_spnego_key_type);
1093 out_destroy_request_bufs:
1094 #endif
1095         cifs_destroy_request_bufs();
1096 out_destroy_mids:
1097         cifs_destroy_mids();
1098 out_destroy_inodecache:
1099         cifs_destroy_inodecache();
1100 out_unreg_fscache:
1101         cifs_fscache_unregister();
1102 out_clean_proc:
1103         cifs_proc_clean();
1104         return rc;
1105 }
1106
1107 static void __exit
1108 exit_cifs(void)
1109 {
1110         cFYI(DBG2, "exit_cifs");
1111         cifs_proc_clean();
1112         cifs_fscache_unregister();
1113 #ifdef CONFIG_CIFS_DFS_UPCALL
1114         cifs_dfs_release_automount_timer();
1115 #endif
1116 #ifdef CONFIG_CIFS_ACL
1117         cifs_destroy_idmaptrees();
1118         exit_cifs_idmap();
1119 #endif
1120 #ifdef CONFIG_CIFS_UPCALL
1121         unregister_key_type(&cifs_spnego_key_type);
1122 #endif
1123         unregister_filesystem(&cifs_fs_type);
1124         cifs_destroy_inodecache();
1125         cifs_destroy_mids();
1126         cifs_destroy_request_bufs();
1127 }
1128
1129 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1130 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1131 MODULE_DESCRIPTION
1132     ("VFS to access servers complying with the SNIA CIFS Specification "
1133      "e.g. Samba and Windows");
1134 MODULE_VERSION(CIFS_VERSION);
1135 module_init(init_cifs)
1136 module_exit(exit_cifs)