fs/cifs/cifsfs.c

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