fs/cifs/cifsfs.c

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