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