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