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