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