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