git.oblomov.eu Git - linux-2.6/blob - 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 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  67 module_param(CIFSMaxBufSize, int, 0);
  68 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
  69 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  70 module_param(cifs_min_rcv, int, 0);
  71 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
  72 unsigned int cifs_min_small = 30;
  73 module_param(cifs_min_small, int, 0);
  74 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
  75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  76 module_param(cifs_max_pending, int, 0);
  77 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
  78
  79 extern mempool_t *cifs_sm_req_poolp;
  80 extern mempool_t *cifs_req_poolp;
  81 extern mempool_t *cifs_mid_poolp;
  82
  83 extern kmem_cache_t *cifs_oplock_cachep;
  84
  85 static int
  86 cifs_read_super(struct super_block *sb, void *data,
  87                 const char *devname, int silent)
  88 {
  89         struct inode *inode;
  90         struct cifs_sb_info *cifs_sb;
  91         int rc = 0;
  92
  93         sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
  94         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
  95         cifs_sb = CIFS_SB(sb);
  96         if(cifs_sb == NULL)
  97                 return -ENOMEM;
  98
  99         rc = cifs_mount(sb, cifs_sb, data, devname);
 100
 101         if (rc) {
 102                 if (!silent)
 103                         cERROR(1,
 104                                ("cifs_mount failed w/return code = %d", rc));
 105                 goto out_mount_failed;
 106         }
 107
 108         sb->s_magic = CIFS_MAGIC_NUMBER;
 109         sb->s_op = &cifs_super_ops;
 110 /*      if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
 111             sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 112 #ifdef CONFIG_CIFS_QUOTA
 113         sb->s_qcop = &cifs_quotactl_ops;
 114 #endif
 115         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 116         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 117         inode = iget(sb, ROOT_I);
 118
 119         if (!inode) {
 120                 rc = -ENOMEM;
 121                 goto out_no_root;
 122         }
 123
 124         sb->s_root = d_alloc_root(inode);
 125
 126         if (!sb->s_root) {
 127                 rc = -ENOMEM;
 128                 goto out_no_root;
 129         }
 130
 131         return 0;
 132
 133 out_no_root:
 134         cERROR(1, ("cifs_read_super: get root inode failed"));
 135         if (inode)
 136                 iput(inode);
 137
 138 out_mount_failed:
 139         if(cifs_sb) {
 140                 if(cifs_sb->local_nls)
 141                         unload_nls(cifs_sb->local_nls);
 142                 kfree(cifs_sb);
 143         }
 144         return rc;
 145 }
 146
 147 static void
 148 cifs_put_super(struct super_block *sb)
 149 {
 150         int rc = 0;
 151         struct cifs_sb_info *cifs_sb;
 152
 153         cFYI(1, ("In cifs_put_super"));
 154         cifs_sb = CIFS_SB(sb);
 155         if(cifs_sb == NULL) {
 156                 cFYI(1,("Empty cifs superblock info passed to unmount"));
 157                 return;
 158         }
 159         rc = cifs_umount(sb, cifs_sb);
 160         if (rc) {
 161                 cERROR(1, ("cifs_umount failed with return code %d", rc));
 162         }
 163         unload_nls(cifs_sb->local_nls);
 164         kfree(cifs_sb);
 165         return;
 166 }
 167
 168 static int
 169 cifs_statfs(struct super_block *sb, struct kstatfs *buf)
 170 {
 171         int xid;
 172         int rc = -EOPNOTSUPP;
 173         struct cifs_sb_info *cifs_sb;
 174         struct cifsTconInfo *pTcon;
 175
 176         xid = GetXid();
 177
 178         cifs_sb = CIFS_SB(sb);
 179         pTcon = cifs_sb->tcon;
 180
 181         buf->f_type = CIFS_MAGIC_NUMBER;
 182
 183         /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
 184         buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
 185                                       presumably be total path, but note
 186                                       that some servers (includinng Samba 3)
 187                                       have a shorter maximum path */
 188         buf->f_files = 0;       /* undefined */
 189         buf->f_ffree = 0;       /* unlimited */
 190
 191 #ifdef CONFIG_CIFS_EXPERIMENTAL
 192 /* BB we could add a second check for a QFS Unix capability bit */
 193 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
 194     if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
 195                         le64_to_cpu(pTcon->fsUnixInfo.Capability)))
 196             rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
 197
 198     /* Only need to call the old QFSInfo if failed
 199     on newer one */
 200     if(rc)
 201 #endif /* CIFS_EXPERIMENTAL */
 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 #ifdef CONFIG_CIFS_EXPERIMENTAL
 405 static void cifs_umount_begin(struct super_block * sblock)
 406 {
 407         struct cifs_sb_info *cifs_sb;
 408         struct cifsTconInfo * tcon;
 409
 410         cifs_sb = CIFS_SB(sblock);
 411         if(cifs_sb == NULL)
 412                 return;
 413
 414         tcon = cifs_sb->tcon;
 415         if(tcon == NULL)
 416                 return;
 417         down(&tcon->tconSem);
 418         if (atomic_read(&tcon->useCount) == 1)
 419                 tcon->tidStatus = CifsExiting;
 420         up(&tcon->tconSem);
 421
 422         /* cancel_brl_requests(tcon); */
 423         /* cancel_notify_requests(tcon); */
 424         if(tcon->ses && tcon->ses->server)
 425         {
 426                 cFYI(1,("wake up tasks now - umount begin not complete"));
 427                 wake_up_all(&tcon->ses->server->request_q);
 428                 wake_up_all(&tcon->ses->server->response_q);
 429                 msleep(1); /* yield */
 430                 /* we have to kick the requests once more */
 431                 wake_up_all(&tcon->ses->server->response_q);
 432                 msleep(1);
 433         }
 434 /* BB FIXME - finish add checks for tidStatus BB */
 435
 436         return;
 437 }
 438 #endif
 439
 440 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 441 {
 442         *flags |= MS_NODIRATIME;
 443         return 0;
 444 }
 445
 446 struct super_operations cifs_super_ops = {
 447         .read_inode = cifs_read_inode,
 448         .put_super = cifs_put_super,
 449         .statfs = cifs_statfs,
 450         .alloc_inode = cifs_alloc_inode,
 451         .destroy_inode = cifs_destroy_inode,
 452 /*      .drop_inode         = generic_delete_inode,
 453         .delete_inode   = cifs_delete_inode,  *//* Do not need the above two functions
 454    unless later we add lazy close of inodes or unless the kernel forgets to call
 455    us with the same number of releases (closes) as opens */
 456         .show_options = cifs_show_options,
 457 #ifdef CONFIG_CIFS_EXPERIMENTAL
 458         .umount_begin   = cifs_umount_begin,
 459 #endif
 460         .remount_fs = cifs_remount,
 461 };
 462
 463 static struct super_block *
 464 cifs_get_sb(struct file_system_type *fs_type,
 465             int flags, const char *dev_name, void *data)
 466 {
 467         int rc;
 468         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
 469
 470         cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
 471
 472         if (IS_ERR(sb))
 473                 return sb;
 474
 475         sb->s_flags = flags;
 476
 477         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
 478         if (rc) {
 479                 up_write(&sb->s_umount);
 480                 deactivate_super(sb);
 481                 return ERR_PTR(rc);
 482         }
 483         sb->s_flags |= MS_ACTIVE;
 484         return sb;
 485 }
 486
 487 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
 488                                 unsigned long nr_segs, loff_t *ppos)
 489 {
 490         struct inode *inode = file->f_dentry->d_inode;
 491         ssize_t written;
 492
 493         written = generic_file_writev(file, iov, nr_segs, ppos);
 494         if (!CIFS_I(inode)->clientCanCacheAll)
 495                 filemap_fdatawrite(inode->i_mapping);
 496         return written;
 497 }
 498
 499 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char __user *buf,
 500                                    size_t count, loff_t pos)
 501 {
 502         struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
 503         ssize_t written;
 504
 505         written = generic_file_aio_write(iocb, buf, count, pos);
 506         if (!CIFS_I(inode)->clientCanCacheAll)
 507                 filemap_fdatawrite(inode->i_mapping);
 508         return written;
 509 }
 510
 511 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 512 {
 513         /* origin == SEEK_END => we must revalidate the cached file length */
 514         if (origin == 2) {
 515                 int retval = cifs_revalidate(file->f_dentry);
 516                 if (retval < 0)
 517                         return (loff_t)retval;
 518         }
 519         return remote_llseek(file, offset, origin);
 520 }
 521
 522 static struct file_system_type cifs_fs_type = {
 523         .owner = THIS_MODULE,
 524         .name = "cifs",
 525         .get_sb = cifs_get_sb,
 526         .kill_sb = kill_anon_super,
 527         /*  .fs_flags */
 528 };
 529 struct inode_operations cifs_dir_inode_ops = {
 530         .create = cifs_create,
 531         .lookup = cifs_lookup,
 532         .getattr = cifs_getattr,
 533         .unlink = cifs_unlink,
 534         .link = cifs_hardlink,
 535         .mkdir = cifs_mkdir,
 536         .rmdir = cifs_rmdir,
 537         .rename = cifs_rename,
 538         .permission = cifs_permission,
 539 /*      revalidate:cifs_revalidate,   */
 540         .setattr = cifs_setattr,
 541         .symlink = cifs_symlink,
 542         .mknod   = cifs_mknod,
 543 #ifdef CONFIG_CIFS_XATTR
 544         .setxattr = cifs_setxattr,
 545         .getxattr = cifs_getxattr,
 546         .listxattr = cifs_listxattr,
 547         .removexattr = cifs_removexattr,
 548 #endif
 549 };
 550
 551 struct inode_operations cifs_file_inode_ops = {
 552 /*      revalidate:cifs_revalidate, */
 553         .setattr = cifs_setattr,
 554         .getattr = cifs_getattr, /* do we need this anymore? */
 555         .rename = cifs_rename,
 556         .permission = cifs_permission,
 557 #ifdef CONFIG_CIFS_XATTR
 558         .setxattr = cifs_setxattr,
 559         .getxattr = cifs_getxattr,
 560         .listxattr = cifs_listxattr,
 561         .removexattr = cifs_removexattr,
 562 #endif
 563 };
 564
 565 struct inode_operations cifs_symlink_inode_ops = {
 566         .readlink = generic_readlink,
 567         .follow_link = cifs_follow_link,
 568         .put_link = cifs_put_link,
 569         .permission = cifs_permission,
 570         /* BB add the following two eventually */
 571         /* revalidate: cifs_revalidate,
 572            setattr:    cifs_notify_change, *//* BB do we need notify change */
 573 #ifdef CONFIG_CIFS_XATTR
 574         .setxattr = cifs_setxattr,
 575         .getxattr = cifs_getxattr,
 576         .listxattr = cifs_listxattr,
 577         .removexattr = cifs_removexattr,
 578 #endif
 579 };
 580
 581 const struct file_operations cifs_file_ops = {
 582         .read = do_sync_read,
 583         .write = do_sync_write,
 584         .readv = generic_file_readv,
 585         .writev = cifs_file_writev,
 586         .aio_read = generic_file_aio_read,
 587         .aio_write = cifs_file_aio_write,
 588         .open = cifs_open,
 589         .release = cifs_close,
 590         .lock = cifs_lock,
 591         .fsync = cifs_fsync,
 592         .flush = cifs_flush,
 593         .mmap  = cifs_file_mmap,
 594         .sendfile = generic_file_sendfile,
 595         .llseek = cifs_llseek,
 596 #ifdef CONFIG_CIFS_POSIX
 597         .ioctl  = cifs_ioctl,
 598 #endif /* CONFIG_CIFS_POSIX */
 599
 600 #ifdef CONFIG_CIFS_EXPERIMENTAL
 601         .dir_notify = cifs_dir_notify,
 602 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 603 };
 604
 605 const struct file_operations cifs_file_direct_ops = {
 606         /* no mmap, no aio, no readv -
 607            BB reevaluate whether they can be done with directio, no cache */
 608         .read = cifs_user_read,
 609         .write = cifs_user_write,
 610         .open = cifs_open,
 611         .release = cifs_close,
 612         .lock = cifs_lock,
 613         .fsync = cifs_fsync,
 614         .flush = cifs_flush,
 615         .sendfile = generic_file_sendfile, /* BB removeme BB */
 616 #ifdef CONFIG_CIFS_POSIX
 617         .ioctl  = cifs_ioctl,
 618 #endif /* CONFIG_CIFS_POSIX */
 619         .llseek = cifs_llseek,
 620 #ifdef CONFIG_CIFS_EXPERIMENTAL
 621         .dir_notify = cifs_dir_notify,
 622 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 623 };
 624 const struct file_operations cifs_file_nobrl_ops = {
 625         .read = do_sync_read,
 626         .write = do_sync_write,
 627         .readv = generic_file_readv,
 628         .writev = cifs_file_writev,
 629         .aio_read = generic_file_aio_read,
 630         .aio_write = cifs_file_aio_write,
 631         .open = cifs_open,
 632         .release = cifs_close,
 633         .fsync = cifs_fsync,
 634         .flush = cifs_flush,
 635         .mmap  = cifs_file_mmap,
 636         .sendfile = generic_file_sendfile,
 637         .llseek = cifs_llseek,
 638 #ifdef CONFIG_CIFS_POSIX
 639         .ioctl  = cifs_ioctl,
 640 #endif /* CONFIG_CIFS_POSIX */
 641
 642 #ifdef CONFIG_CIFS_EXPERIMENTAL
 643         .dir_notify = cifs_dir_notify,
 644 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 645 };
 646
 647 const struct file_operations cifs_file_direct_nobrl_ops = {
 648         /* no mmap, no aio, no readv -
 649            BB reevaluate whether they can be done with directio, no cache */
 650         .read = cifs_user_read,
 651         .write = cifs_user_write,
 652         .open = cifs_open,
 653         .release = cifs_close,
 654         .fsync = cifs_fsync,
 655         .flush = cifs_flush,
 656         .sendfile = generic_file_sendfile, /* BB removeme BB */
 657 #ifdef CONFIG_CIFS_POSIX
 658         .ioctl  = cifs_ioctl,
 659 #endif /* CONFIG_CIFS_POSIX */
 660         .llseek = cifs_llseek,
 661 #ifdef CONFIG_CIFS_EXPERIMENTAL
 662         .dir_notify = cifs_dir_notify,
 663 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 664 };
 665
 666 const struct file_operations cifs_dir_ops = {
 667         .readdir = cifs_readdir,
 668         .release = cifs_closedir,
 669         .read    = generic_read_dir,
 670 #ifdef CONFIG_CIFS_EXPERIMENTAL
 671         .dir_notify = cifs_dir_notify,
 672 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 673         .ioctl  = cifs_ioctl,
 674 };
 675
 676 static void
 677 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
 678 {
 679         struct cifsInodeInfo *cifsi = inode;
 680
 681         if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
 682             SLAB_CTOR_CONSTRUCTOR) {
 683                 inode_init_once(&cifsi->vfs_inode);
 684                 INIT_LIST_HEAD(&cifsi->lockList);
 685         }
 686 }
 687
 688 static int
 689 cifs_init_inodecache(void)
 690 {
 691         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 692                                               sizeof (struct cifsInodeInfo),
 693                                               0, (SLAB_RECLAIM_ACCOUNT|
 694                                                 SLAB_MEM_SPREAD),
 695                                               cifs_init_once, NULL);
 696         if (cifs_inode_cachep == NULL)
 697                 return -ENOMEM;
 698
 699         return 0;
 700 }
 701
 702 static void
 703 cifs_destroy_inodecache(void)
 704 {
 705         if (kmem_cache_destroy(cifs_inode_cachep))
 706                 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
 707 }
 708
 709 static int
 710 cifs_init_request_bufs(void)
 711 {
 712         if(CIFSMaxBufSize < 8192) {
 713         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 714         Unicode path name has to fit in any SMB/CIFS path based frames */
 715                 CIFSMaxBufSize = 8192;
 716         } else if (CIFSMaxBufSize > 1024*127) {
 717                 CIFSMaxBufSize = 1024 * 127;
 718         } else {
 719                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 720         }
 721 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 722         cifs_req_cachep = kmem_cache_create("cifs_request",
 723                                             CIFSMaxBufSize +
 724                                             MAX_CIFS_HDR_SIZE, 0,
 725                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
 726         if (cifs_req_cachep == NULL)
 727                 return -ENOMEM;
 728
 729         if(cifs_min_rcv < 1)
 730                 cifs_min_rcv = 1;
 731         else if (cifs_min_rcv > 64) {
 732                 cifs_min_rcv = 64;
 733                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
 734         }
 735
 736         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 737                                                   cifs_req_cachep);
 738
 739         if(cifs_req_poolp == NULL) {
 740                 kmem_cache_destroy(cifs_req_cachep);
 741                 return -ENOMEM;
 742         }
 743         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 744         almost all handle based requests (but not write response, nor is it
 745         sufficient for path based requests).  A smaller size would have
 746         been more efficient (compacting multiple slab items on one 4k page)
 747         for the case in which debug was on, but this larger size allows
 748         more SMBs to use small buffer alloc and is still much more
 749         efficient to alloc 1 per page off the slab compared to 17K (5page)
 750         alloc of large cifs buffers even when page debugging is on */
 751         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 752                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 753                         NULL, NULL);
 754         if (cifs_sm_req_cachep == NULL) {
 755                 mempool_destroy(cifs_req_poolp);
 756                 kmem_cache_destroy(cifs_req_cachep);
 757                 return -ENOMEM;
 758         }
 759
 760         if(cifs_min_small < 2)
 761                 cifs_min_small = 2;
 762         else if (cifs_min_small > 256) {
 763                 cifs_min_small = 256;
 764                 cFYI(1,("cifs_min_small set to maximum (256)"));
 765         }
 766
 767         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 768                                                      cifs_sm_req_cachep);
 769
 770         if(cifs_sm_req_poolp == NULL) {
 771                 mempool_destroy(cifs_req_poolp);
 772                 kmem_cache_destroy(cifs_req_cachep);
 773                 kmem_cache_destroy(cifs_sm_req_cachep);
 774                 return -ENOMEM;
 775         }
 776
 777         return 0;
 778 }
 779
 780 static void
 781 cifs_destroy_request_bufs(void)
 782 {
 783         mempool_destroy(cifs_req_poolp);
 784         if (kmem_cache_destroy(cifs_req_cachep))
 785                 printk(KERN_WARNING
 786                        "cifs_destroy_request_cache: error not all structures were freed\n");
 787         mempool_destroy(cifs_sm_req_poolp);
 788         if (kmem_cache_destroy(cifs_sm_req_cachep))
 789                 printk(KERN_WARNING
 790                       "cifs_destroy_request_cache: cifs_small_rq free error\n");
 791 }
 792
 793 static int
 794 cifs_init_mids(void)
 795 {
 796         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 797                                 sizeof (struct mid_q_entry), 0,
 798                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 799         if (cifs_mid_cachep == NULL)
 800                 return -ENOMEM;
 801
 802         /* 3 is a reasonable minimum number of simultaneous operations */
 803         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 804         if(cifs_mid_poolp == NULL) {
 805                 kmem_cache_destroy(cifs_mid_cachep);
 806                 return -ENOMEM;
 807         }
 808
 809         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 810                                 sizeof (struct oplock_q_entry), 0,
 811                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 812         if (cifs_oplock_cachep == NULL) {
 813                 kmem_cache_destroy(cifs_mid_cachep);
 814                 mempool_destroy(cifs_mid_poolp);
 815                 return -ENOMEM;
 816         }
 817
 818         return 0;
 819 }
 820
 821 static void
 822 cifs_destroy_mids(void)
 823 {
 824         mempool_destroy(cifs_mid_poolp);
 825         if (kmem_cache_destroy(cifs_mid_cachep))
 826                 printk(KERN_WARNING
 827                        "cifs_destroy_mids: error not all structures were freed\n");
 828
 829         if (kmem_cache_destroy(cifs_oplock_cachep))
 830                 printk(KERN_WARNING
 831                        "error not all oplock structures were freed\n");
 832 }
 833
 834 static int cifs_oplock_thread(void * dummyarg)
 835 {
 836         struct oplock_q_entry * oplock_item;
 837         struct cifsTconInfo *pTcon;
 838         struct inode * inode;
 839         __u16  netfid;
 840         int rc;
 841
 842         do {
 843                 if (try_to_freeze())
 844                         continue;
 845
 846                 spin_lock(&GlobalMid_Lock);
 847                 if(list_empty(&GlobalOplock_Q)) {
 848                         spin_unlock(&GlobalMid_Lock);
 849                         set_current_state(TASK_INTERRUPTIBLE);
 850                         schedule_timeout(39*HZ);
 851                 } else {
 852                         oplock_item = list_entry(GlobalOplock_Q.next,
 853                                 struct oplock_q_entry, qhead);
 854                         if(oplock_item) {
 855                                 cFYI(1,("found oplock item to write out"));
 856                                 pTcon = oplock_item->tcon;
 857                                 inode = oplock_item->pinode;
 858                                 netfid = oplock_item->netfid;
 859                                 spin_unlock(&GlobalMid_Lock);
 860                                 DeleteOplockQEntry(oplock_item);
 861                                 /* can not grab inode sem here since it would
 862                                 deadlock when oplock received on delete
 863                                 since vfs_unlink holds the i_mutex across
 864                                 the call */
 865                                 /* mutex_lock(&inode->i_mutex);*/
 866                                 if (S_ISREG(inode->i_mode)) {
 867                                         rc = filemap_fdatawrite(inode->i_mapping);
 868                                         if(CIFS_I(inode)->clientCanCacheRead == 0) {
 869                                                 filemap_fdatawait(inode->i_mapping);
 870                                                 invalidate_remote_inode(inode);
 871                                         }
 872                                 } else
 873                                         rc = 0;
 874                                 /* mutex_unlock(&inode->i_mutex);*/
 875                                 if (rc)
 876                                         CIFS_I(inode)->write_behind_rc = rc;
 877                                 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
 878
 879                                 /* releasing a stale oplock after recent reconnection
 880                                 of smb session using a now incorrect file
 881                                 handle is not a data integrity issue but do
 882                                 not bother sending an oplock release if session
 883                                 to server still is disconnected since oplock
 884                                 already released by the server in that case */
 885                                 if(pTcon->tidStatus != CifsNeedReconnect) {
 886                                     rc = CIFSSMBLock(0, pTcon, netfid,
 887                                             0 /* len */ , 0 /* offset */, 0,
 888                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
 889                                             0 /* wait flag */);
 890                                         cFYI(1,("Oplock release rc = %d ",rc));
 891                                 }
 892                         } else
 893                                 spin_unlock(&GlobalMid_Lock);
 894                         set_current_state(TASK_INTERRUPTIBLE);
 895                         schedule_timeout(1);  /* yield in case q were corrupt */
 896                 }
 897         } while (!kthread_should_stop());
 898
 899         return 0;
 900 }
 901
 902 static int cifs_dnotify_thread(void * dummyarg)
 903 {
 904         struct list_head *tmp;
 905         struct cifsSesInfo *ses;
 906
 907         do {
 908                 if (try_to_freeze())
 909                         continue;
 910                 set_current_state(TASK_INTERRUPTIBLE);
 911                 schedule_timeout(15*HZ);
 912                 read_lock(&GlobalSMBSeslock);
 913                 /* check if any stuck requests that need
 914                    to be woken up and wakeq so the
 915                    thread can wake up and error out */
 916                 list_for_each(tmp, &GlobalSMBSessionList) {
 917                         ses = list_entry(tmp, struct cifsSesInfo,
 918                                 cifsSessionList);
 919                         if(ses && ses->server &&
 920                              atomic_read(&ses->server->inFlight))
 921                                 wake_up_all(&ses->server->response_q);
 922                 }
 923                 read_unlock(&GlobalSMBSeslock);
 924         } while (!kthread_should_stop());
 925
 926         return 0;
 927 }
 928
 929 static int __init
 930 init_cifs(void)
 931 {
 932         int rc = 0;
 933 #ifdef CONFIG_PROC_FS
 934         cifs_proc_init();
 935 #endif
 936         INIT_LIST_HEAD(&GlobalServerList);      /* BB not implemented yet */
 937         INIT_LIST_HEAD(&GlobalSMBSessionList);
 938         INIT_LIST_HEAD(&GlobalTreeConnectionList);
 939         INIT_LIST_HEAD(&GlobalOplock_Q);
 940 #ifdef CONFIG_CIFS_EXPERIMENTAL
 941         INIT_LIST_HEAD(&GlobalDnotifyReqList);
 942         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
 943 #endif
 944 /*
 945  *  Initialize Global counters
 946  */
 947         atomic_set(&sesInfoAllocCount, 0);
 948         atomic_set(&tconInfoAllocCount, 0);
 949         atomic_set(&tcpSesAllocCount,0);
 950         atomic_set(&tcpSesReconnectCount, 0);
 951         atomic_set(&tconInfoReconnectCount, 0);
 952
 953         atomic_set(&bufAllocCount, 0);
 954         atomic_set(&smBufAllocCount, 0);
 955 #ifdef CONFIG_CIFS_STATS2
 956         atomic_set(&totBufAllocCount, 0);
 957         atomic_set(&totSmBufAllocCount, 0);
 958 #endif /* CONFIG_CIFS_STATS2 */
 959
 960         atomic_set(&midCount, 0);
 961         GlobalCurrentXid = 0;
 962         GlobalTotalActiveXid = 0;
 963         GlobalMaxActiveXid = 0;
 964         rwlock_init(&GlobalSMBSeslock);
 965         spin_lock_init(&GlobalMid_Lock);
 966
 967         if(cifs_max_pending < 2) {
 968                 cifs_max_pending = 2;
 969                 cFYI(1,("cifs_max_pending set to min of 2"));
 970         } else if(cifs_max_pending > 256) {
 971                 cifs_max_pending = 256;
 972                 cFYI(1,("cifs_max_pending set to max of 256"));
 973         }
 974
 975         rc = cifs_init_inodecache();
 976         if (rc)
 977                 goto out_clean_proc;
 978
 979         rc = cifs_init_mids();
 980         if (rc)
 981                 goto out_destroy_inodecache;
 982
 983         rc = cifs_init_request_bufs();
 984         if (rc)
 985                 goto out_destroy_mids;
 986
 987         rc = register_filesystem(&cifs_fs_type);
 988         if (rc)
 989                 goto out_destroy_request_bufs;
 990
 991         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
 992         if (IS_ERR(oplockThread)) {
 993                 rc = PTR_ERR(oplockThread);
 994                 cERROR(1,("error %d create oplock thread", rc));
 995                 goto out_unregister_filesystem;
 996         }
 997
 998         dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
 999         if (IS_ERR(dnotifyThread)) {
1000                 rc = PTR_ERR(dnotifyThread);
1001                 cERROR(1,("error %d create dnotify thread", rc));
1002                 goto out_stop_oplock_thread;
1003         }
1004
1005         return 0;
1006
1007  out_stop_oplock_thread:
1008         kthread_stop(oplockThread);
1009  out_unregister_filesystem:
1010         unregister_filesystem(&cifs_fs_type);
1011  out_destroy_request_bufs:
1012         cifs_destroy_request_bufs();
1013  out_destroy_mids:
1014         cifs_destroy_mids();
1015  out_destroy_inodecache:
1016         cifs_destroy_inodecache();
1017  out_clean_proc:
1018 #ifdef CONFIG_PROC_FS
1019         cifs_proc_clean();
1020 #endif
1021         return rc;
1022 }
1023
1024 static void __exit
1025 exit_cifs(void)
1026 {
1027         cFYI(0, ("In unregister ie exit_cifs"));
1028 #ifdef CONFIG_PROC_FS
1029         cifs_proc_clean();
1030 #endif
1031         unregister_filesystem(&cifs_fs_type);
1032         cifs_destroy_inodecache();
1033         cifs_destroy_mids();
1034         cifs_destroy_request_bufs();
1035         kthread_stop(oplockThread);
1036         kthread_stop(dnotifyThread);
1037 }
1038
1039 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1040 MODULE_LICENSE("GPL");          /* combination of LGPL + GPL source behaves as GPL */
1041 MODULE_DESCRIPTION
1042     ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1043 MODULE_VERSION(CIFS_VERSION);
1044 module_init(init_cifs)
1045 module_exit(exit_cifs)