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