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