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 "cifsfs.h"
  37 #include "cifspdu.h"
  38 #define DECLARE_GLOBALS_HERE
  39 #include "cifsglob.h"
  40 #include "cifsproto.h"
  41 #include "cifs_debug.h"
  42 #include "cifs_fs_sb.h"
  43 #include <linux/mm.h>
  44 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
  45
  46 #ifdef CONFIG_CIFS_QUOTA
  47 static struct quotactl_ops cifs_quotactl_ops;
  48 #endif
  49
  50 int cifsFYI = 0;
  51 int cifsERROR = 1;
  52 int traceSMB = 0;
  53 unsigned int oplockEnabled = 1;
  54 unsigned int experimEnabled = 0;
  55 unsigned int linuxExtEnabled = 1;
  56 unsigned int lookupCacheEnabled = 1;
  57 unsigned int multiuser_mount = 0;
  58 unsigned int extended_security = 0;
  59 unsigned int ntlmv2_support = 0;
  60 unsigned int sign_CIFS_PDUs = 1;
  61 extern struct task_struct * oplockThread; /* remove sparse warning */
  62 struct task_struct * oplockThread = NULL;
  63 extern struct task_struct * dnotifyThread; /* remove sparse warning */
  64 struct task_struct * dnotifyThread = NULL;
  65 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  66 module_param(CIFSMaxBufSize, int, 0);
  67 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
  68 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  69 module_param(cifs_min_rcv, int, 0);
  70 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
  71 unsigned int cifs_min_small = 30;
  72 module_param(cifs_min_small, int, 0);
  73 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
  74 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  75 module_param(cifs_max_pending, int, 0);
  76 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
  77
  78 static DECLARE_COMPLETION(cifs_oplock_exited);
  79 static DECLARE_COMPLETION(cifs_dnotify_exited);
  80
  81 extern mempool_t *cifs_sm_req_poolp;
  82 extern mempool_t *cifs_req_poolp;
  83 extern mempool_t *cifs_mid_poolp;
  84
  85 extern kmem_cache_t *cifs_oplock_cachep;
  86
  87 static int
  88 cifs_read_super(struct super_block *sb, void *data,
  89                 const char *devname, int silent)
  90 {
  91         struct inode *inode;
  92         struct cifs_sb_info *cifs_sb;
  93         int rc = 0;
  94
  95         sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
  96         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
  97         cifs_sb = CIFS_SB(sb);
  98         if(cifs_sb == NULL)
  99                 return -ENOMEM;
 100
 101         rc = cifs_mount(sb, cifs_sb, data, devname);
 102
 103         if (rc) {
 104                 if (!silent)
 105                         cERROR(1,
 106                                ("cifs_mount failed w/return code = %d", rc));
 107                 goto out_mount_failed;
 108         }
 109
 110         sb->s_magic = CIFS_MAGIC_NUMBER;
 111         sb->s_op = &cifs_super_ops;
 112 /*      if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
 113             sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 114 #ifdef CONFIG_CIFS_QUOTA
 115         sb->s_qcop = &cifs_quotactl_ops;
 116 #endif
 117         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 118         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 119         inode = iget(sb, ROOT_I);
 120
 121         if (!inode) {
 122                 rc = -ENOMEM;
 123                 goto out_no_root;
 124         }
 125
 126         sb->s_root = d_alloc_root(inode);
 127
 128         if (!sb->s_root) {
 129                 rc = -ENOMEM;
 130                 goto out_no_root;
 131         }
 132
 133         return 0;
 134
 135 out_no_root:
 136         cERROR(1, ("cifs_read_super: get root inode failed"));
 137         if (inode)
 138                 iput(inode);
 139
 140 out_mount_failed:
 141         if(cifs_sb) {
 142                 if(cifs_sb->local_nls)
 143                         unload_nls(cifs_sb->local_nls);
 144                 kfree(cifs_sb);
 145         }
 146         return rc;
 147 }
 148
 149 static void
 150 cifs_put_super(struct super_block *sb)
 151 {
 152         int rc = 0;
 153         struct cifs_sb_info *cifs_sb;
 154
 155         cFYI(1, ("In cifs_put_super"));
 156         cifs_sb = CIFS_SB(sb);
 157         if(cifs_sb == NULL) {
 158                 cFYI(1,("Empty cifs superblock info passed to unmount"));
 159                 return;
 160         }
 161         rc = cifs_umount(sb, cifs_sb);
 162         if (rc) {
 163                 cERROR(1, ("cifs_umount failed with return code %d", rc));
 164         }
 165         unload_nls(cifs_sb->local_nls);
 166         kfree(cifs_sb);
 167         return;
 168 }
 169
 170 static int
 171 cifs_statfs(struct super_block *sb, struct kstatfs *buf)
 172 {
 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 #ifdef CONFIG_CIFS_EXPERIMENTAL
 194 /* BB we could add a second check for a QFS Unix capability bit */
 195 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
 196     if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
 197                         le64_to_cpu(pTcon->fsUnixInfo.Capability)))
 198             rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
 199
 200     /* Only need to call the old QFSInfo if failed
 201     on newer one */
 202     if(rc)
 203 #endif /* CIFS_EXPERIMENTAL */
 204         rc = CIFSSMBQFSInfo(xid, pTcon, buf);
 205
 206         /* Old Windows servers do not support level 103, retry with level
 207            one if old server failed the previous call */
 208         if(rc)
 209                 rc = SMBOldQFSInfo(xid, pTcon, buf);
 210         /*
 211            int f_type;
 212            __fsid_t f_fsid;
 213            int f_namelen;  */
 214         /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
 215         FreeXid(xid);
 216         return 0;               /* always return success? what if volume is no
 217                                    longer available? */
 218 }
 219
 220 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
 221 {
 222         struct cifs_sb_info *cifs_sb;
 223
 224         cifs_sb = CIFS_SB(inode->i_sb);
 225
 226         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 227                 return 0;
 228         } else /* file mode might have been restricted at mount time
 229                 on the client (above and beyond ACL on servers) for
 230                 servers which do not support setting and viewing mode bits,
 231                 so allowing client to check permissions is useful */
 232                 return generic_permission(inode, mask, NULL);
 233 }
 234
 235 static kmem_cache_t *cifs_inode_cachep;
 236 static kmem_cache_t *cifs_req_cachep;
 237 static kmem_cache_t *cifs_mid_cachep;
 238 kmem_cache_t *cifs_oplock_cachep;
 239 static kmem_cache_t *cifs_sm_req_cachep;
 240 mempool_t *cifs_sm_req_poolp;
 241 mempool_t *cifs_req_poolp;
 242 mempool_t *cifs_mid_poolp;
 243
 244 static struct inode *
 245 cifs_alloc_inode(struct super_block *sb)
 246 {
 247         struct cifsInodeInfo *cifs_inode;
 248         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
 249         if (!cifs_inode)
 250                 return NULL;
 251         cifs_inode->cifsAttrs = 0x20;   /* default */
 252         atomic_set(&cifs_inode->inUse, 0);
 253         cifs_inode->time = 0;
 254         /* Until the file is open and we have gotten oplock
 255         info back from the server, can not assume caching of
 256         file data or metadata */
 257         cifs_inode->clientCanCacheRead = FALSE;
 258         cifs_inode->clientCanCacheAll = FALSE;
 259         cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
 260         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 261         cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
 262         INIT_LIST_HEAD(&cifs_inode->openFileList);
 263         return &cifs_inode->vfs_inode;
 264 }
 265
 266 static void
 267 cifs_destroy_inode(struct inode *inode)
 268 {
 269         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 270 }
 271
 272 /*
 273  * cifs_show_options() is for displaying mount options in /proc/mounts.
 274  * Not all settable options are displayed but most of the important
 275  * ones are.
 276  */
 277 static int
 278 cifs_show_options(struct seq_file *s, struct vfsmount *m)
 279 {
 280         struct cifs_sb_info *cifs_sb;
 281
 282         cifs_sb = CIFS_SB(m->mnt_sb);
 283
 284         if (cifs_sb) {
 285                 if (cifs_sb->tcon) {
 286                         seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
 287                         if (cifs_sb->tcon->ses) {
 288                                 if (cifs_sb->tcon->ses->userName)
 289                                         seq_printf(s, ",username=%s",
 290                                            cifs_sb->tcon->ses->userName);
 291                                 if(cifs_sb->tcon->ses->domainName)
 292                                         seq_printf(s, ",domain=%s",
 293                                            cifs_sb->tcon->ses->domainName);
 294                         }
 295                 }
 296                 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
 297                 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
 298         }
 299         return 0;
 300 }
 301
 302 #ifdef CONFIG_CIFS_QUOTA
 303 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
 304                 struct fs_disk_quota * pdquota)
 305 {
 306         int xid;
 307         int rc = 0;
 308         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 309         struct cifsTconInfo *pTcon;
 310
 311         if(cifs_sb)
 312                 pTcon = cifs_sb->tcon;
 313         else
 314                 return -EIO;
 315
 316
 317         xid = GetXid();
 318         if(pTcon) {
 319                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 320         } else {
 321                 return -EIO;
 322         }
 323
 324         FreeXid(xid);
 325         return rc;
 326 }
 327
 328 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
 329                 struct fs_disk_quota * pdquota)
 330 {
 331         int xid;
 332         int rc = 0;
 333         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 334         struct cifsTconInfo *pTcon;
 335
 336         if(cifs_sb)
 337                 pTcon = cifs_sb->tcon;
 338         else
 339                 return -EIO;
 340
 341         xid = GetXid();
 342         if(pTcon) {
 343                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 344         } else {
 345                 rc = -EIO;
 346         }
 347
 348         FreeXid(xid);
 349         return rc;
 350 }
 351
 352 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
 353 {
 354         int xid;
 355         int rc = 0;
 356         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 357         struct cifsTconInfo *pTcon;
 358
 359         if(cifs_sb)
 360                 pTcon = cifs_sb->tcon;
 361         else
 362                 return -EIO;
 363
 364         xid = GetXid();
 365         if(pTcon) {
 366                 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
 367         } else {
 368                 rc = -EIO;
 369         }
 370
 371         FreeXid(xid);
 372         return rc;
 373 }
 374
 375 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
 376 {
 377         int xid;
 378         int rc = 0;
 379         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 380         struct cifsTconInfo *pTcon;
 381
 382         if(cifs_sb) {
 383                 pTcon = cifs_sb->tcon;
 384         } else {
 385                 return -EIO;
 386         }
 387         xid = GetXid();
 388         if(pTcon) {
 389                 cFYI(1,("pqstats %p",qstats));
 390         } else {
 391                 rc = -EIO;
 392         }
 393
 394         FreeXid(xid);
 395         return rc;
 396 }
 397
 398 static struct quotactl_ops cifs_quotactl_ops = {
 399         .set_xquota     = cifs_xquota_set,
 400         .get_xquota     = cifs_xquota_set,
 401         .set_xstate     = cifs_xstate_set,
 402         .get_xstate     = cifs_xstate_get,
 403 };
 404 #endif
 405
 406 #ifdef CONFIG_CIFS_EXPERIMENTAL
 407 static void cifs_umount_begin(struct super_block * sblock)
 408 {
 409         struct cifs_sb_info *cifs_sb;
 410         struct cifsTconInfo * tcon;
 411
 412         cifs_sb = CIFS_SB(sblock);
 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_VERBOSE ? 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 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 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 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 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 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                                               cifs_init_once, NULL);
 697         if (cifs_inode_cachep == NULL)
 698                 return -ENOMEM;
 699
 700         return 0;
 701 }
 702
 703 static void
 704 cifs_destroy_inodecache(void)
 705 {
 706         if (kmem_cache_destroy(cifs_inode_cachep))
 707                 printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
 708 }
 709
 710 static int
 711 cifs_init_request_bufs(void)
 712 {
 713         if(CIFSMaxBufSize < 8192) {
 714         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 715         Unicode path name has to fit in any SMB/CIFS path based frames */
 716                 CIFSMaxBufSize = 8192;
 717         } else if (CIFSMaxBufSize > 1024*127) {
 718                 CIFSMaxBufSize = 1024 * 127;
 719         } else {
 720                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 721         }
 722 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 723         cifs_req_cachep = kmem_cache_create("cifs_request",
 724                                             CIFSMaxBufSize +
 725                                             MAX_CIFS_HDR_SIZE, 0,
 726                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
 727         if (cifs_req_cachep == NULL)
 728                 return -ENOMEM;
 729
 730         if(cifs_min_rcv < 1)
 731                 cifs_min_rcv = 1;
 732         else if (cifs_min_rcv > 64) {
 733                 cifs_min_rcv = 64;
 734                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
 735         }
 736
 737         cifs_req_poolp = mempool_create(cifs_min_rcv,
 738                                         mempool_alloc_slab,
 739                                         mempool_free_slab,
 740                                         cifs_req_cachep);
 741
 742         if(cifs_req_poolp == NULL) {
 743                 kmem_cache_destroy(cifs_req_cachep);
 744                 return -ENOMEM;
 745         }
 746         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 747         almost all handle based requests (but not write response, nor is it
 748         sufficient for path based requests).  A smaller size would have
 749         been more efficient (compacting multiple slab items on one 4k page)
 750         for the case in which debug was on, but this larger size allows
 751         more SMBs to use small buffer alloc and is still much more
 752         efficient to alloc 1 per page off the slab compared to 17K (5page)
 753         alloc of large cifs buffers even when page debugging is on */
 754         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 755                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 756                         NULL, NULL);
 757         if (cifs_sm_req_cachep == NULL) {
 758                 mempool_destroy(cifs_req_poolp);
 759                 kmem_cache_destroy(cifs_req_cachep);
 760                 return -ENOMEM;
 761         }
 762
 763         if(cifs_min_small < 2)
 764                 cifs_min_small = 2;
 765         else if (cifs_min_small > 256) {
 766                 cifs_min_small = 256;
 767                 cFYI(1,("cifs_min_small set to maximum (256)"));
 768         }
 769
 770         cifs_sm_req_poolp = mempool_create(cifs_min_small,
 771                                 mempool_alloc_slab,
 772                                 mempool_free_slab,
 773                                 cifs_sm_req_cachep);
 774
 775         if(cifs_sm_req_poolp == NULL) {
 776                 mempool_destroy(cifs_req_poolp);
 777                 kmem_cache_destroy(cifs_req_cachep);
 778                 kmem_cache_destroy(cifs_sm_req_cachep);
 779                 return -ENOMEM;
 780         }
 781
 782         return 0;
 783 }
 784
 785 static void
 786 cifs_destroy_request_bufs(void)
 787 {
 788         mempool_destroy(cifs_req_poolp);
 789         if (kmem_cache_destroy(cifs_req_cachep))
 790                 printk(KERN_WARNING
 791                        "cifs_destroy_request_cache: error not all structures were freed\n");
 792         mempool_destroy(cifs_sm_req_poolp);
 793         if (kmem_cache_destroy(cifs_sm_req_cachep))
 794                 printk(KERN_WARNING
 795                       "cifs_destroy_request_cache: cifs_small_rq free error\n");
 796 }
 797
 798 static int
 799 cifs_init_mids(void)
 800 {
 801         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 802                                 sizeof (struct mid_q_entry), 0,
 803                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 804         if (cifs_mid_cachep == NULL)
 805                 return -ENOMEM;
 806
 807         cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
 808                                         mempool_alloc_slab,
 809                                         mempool_free_slab,
 810                                         cifs_mid_cachep);
 811         if(cifs_mid_poolp == NULL) {
 812                 kmem_cache_destroy(cifs_mid_cachep);
 813                 return -ENOMEM;
 814         }
 815
 816         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 817                                 sizeof (struct oplock_q_entry), 0,
 818                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 819         if (cifs_oplock_cachep == NULL) {
 820                 kmem_cache_destroy(cifs_mid_cachep);
 821                 mempool_destroy(cifs_mid_poolp);
 822                 return -ENOMEM;
 823         }
 824
 825         return 0;
 826 }
 827
 828 static void
 829 cifs_destroy_mids(void)
 830 {
 831         mempool_destroy(cifs_mid_poolp);
 832         if (kmem_cache_destroy(cifs_mid_cachep))
 833                 printk(KERN_WARNING
 834                        "cifs_destroy_mids: error not all structures were freed\n");
 835
 836         if (kmem_cache_destroy(cifs_oplock_cachep))
 837                 printk(KERN_WARNING
 838                        "error not all oplock structures were freed\n");
 839 }
 840
 841 static int cifs_oplock_thread(void * dummyarg)
 842 {
 843         struct oplock_q_entry * oplock_item;
 844         struct cifsTconInfo *pTcon;
 845         struct inode * inode;
 846         __u16  netfid;
 847         int rc;
 848
 849         daemonize("cifsoplockd");
 850         allow_signal(SIGTERM);
 851
 852         oplockThread = current;
 853         do {
 854                 if (try_to_freeze())
 855                         continue;
 856
 857                 spin_lock(&GlobalMid_Lock);
 858                 if(list_empty(&GlobalOplock_Q)) {
 859                         spin_unlock(&GlobalMid_Lock);
 860                         set_current_state(TASK_INTERRUPTIBLE);
 861                         schedule_timeout(39*HZ);
 862                 } else {
 863                         oplock_item = list_entry(GlobalOplock_Q.next,
 864                                 struct oplock_q_entry, qhead);
 865                         if(oplock_item) {
 866                                 cFYI(1,("found oplock item to write out"));
 867                                 pTcon = oplock_item->tcon;
 868                                 inode = oplock_item->pinode;
 869                                 netfid = oplock_item->netfid;
 870                                 spin_unlock(&GlobalMid_Lock);
 871                                 DeleteOplockQEntry(oplock_item);
 872                                 /* can not grab inode sem here since it would
 873                                 deadlock when oplock received on delete
 874                                 since vfs_unlink holds the i_mutex across
 875                                 the call */
 876                                 /* mutex_lock(&inode->i_mutex);*/
 877                                 if (S_ISREG(inode->i_mode)) {
 878                                         rc = filemap_fdatawrite(inode->i_mapping);
 879                                         if(CIFS_I(inode)->clientCanCacheRead == 0) {
 880                                                 filemap_fdatawait(inode->i_mapping);
 881                                                 invalidate_remote_inode(inode);
 882                                         }
 883                                 } else
 884                                         rc = 0;
 885                                 /* mutex_unlock(&inode->i_mutex);*/
 886                                 if (rc)
 887                                         CIFS_I(inode)->write_behind_rc = rc;
 888                                 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
 889
 890                                 /* releasing a stale oplock after recent reconnection
 891                                 of smb session using a now incorrect file
 892                                 handle is not a data integrity issue but do
 893                                 not bother sending an oplock release if session
 894                                 to server still is disconnected since oplock
 895                                 already released by the server in that case */
 896                                 if(pTcon->tidStatus != CifsNeedReconnect) {
 897                                     rc = CIFSSMBLock(0, pTcon, netfid,
 898                                             0 /* len */ , 0 /* offset */, 0,
 899                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
 900                                             0 /* wait flag */);
 901                                         cFYI(1,("Oplock release rc = %d ",rc));
 902                                 }
 903                         } else
 904                                 spin_unlock(&GlobalMid_Lock);
 905                         set_current_state(TASK_INTERRUPTIBLE);
 906                         schedule_timeout(1);  /* yield in case q were corrupt */
 907                 }
 908         } while(!signal_pending(current));
 909         oplockThread = NULL;
 910         complete_and_exit (&cifs_oplock_exited, 0);
 911 }
 912
 913 static int cifs_dnotify_thread(void * dummyarg)
 914 {
 915         struct list_head *tmp;
 916         struct cifsSesInfo *ses;
 917
 918         daemonize("cifsdnotifyd");
 919         allow_signal(SIGTERM);
 920
 921         dnotifyThread = current;
 922         do {
 923                 if(try_to_freeze())
 924                         continue;
 925                 set_current_state(TASK_INTERRUPTIBLE);
 926                 schedule_timeout(15*HZ);
 927                 read_lock(&GlobalSMBSeslock);
 928                 /* check if any stuck requests that need
 929                    to be woken up and wakeq so the
 930                    thread can wake up and error out */
 931                 list_for_each(tmp, &GlobalSMBSessionList) {
 932                         ses = list_entry(tmp, struct cifsSesInfo,
 933                                 cifsSessionList);
 934                         if(ses && ses->server &&
 935                              atomic_read(&ses->server->inFlight))
 936                                 wake_up_all(&ses->server->response_q);
 937                 }
 938                 read_unlock(&GlobalSMBSeslock);
 939         } while(!signal_pending(current));
 940         complete_and_exit (&cifs_dnotify_exited, 0);
 941 }
 942
 943 static int __init
 944 init_cifs(void)
 945 {
 946         int rc = 0;
 947 #ifdef CONFIG_PROC_FS
 948         cifs_proc_init();
 949 #endif
 950         INIT_LIST_HEAD(&GlobalServerList);      /* BB not implemented yet */
 951         INIT_LIST_HEAD(&GlobalSMBSessionList);
 952         INIT_LIST_HEAD(&GlobalTreeConnectionList);
 953         INIT_LIST_HEAD(&GlobalOplock_Q);
 954 #ifdef CONFIG_CIFS_EXPERIMENTAL
 955         INIT_LIST_HEAD(&GlobalDnotifyReqList);
 956         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
 957 #endif
 958 /*
 959  *  Initialize Global counters
 960  */
 961         atomic_set(&sesInfoAllocCount, 0);
 962         atomic_set(&tconInfoAllocCount, 0);
 963         atomic_set(&tcpSesAllocCount,0);
 964         atomic_set(&tcpSesReconnectCount, 0);
 965         atomic_set(&tconInfoReconnectCount, 0);
 966
 967         atomic_set(&bufAllocCount, 0);
 968         atomic_set(&smBufAllocCount, 0);
 969 #ifdef CONFIG_CIFS_STATS2
 970         atomic_set(&totBufAllocCount, 0);
 971         atomic_set(&totSmBufAllocCount, 0);
 972 #endif /* CONFIG_CIFS_STATS2 */
 973
 974         atomic_set(&midCount, 0);
 975         GlobalCurrentXid = 0;
 976         GlobalTotalActiveXid = 0;
 977         GlobalMaxActiveXid = 0;
 978         rwlock_init(&GlobalSMBSeslock);
 979         spin_lock_init(&GlobalMid_Lock);
 980
 981         if(cifs_max_pending < 2) {
 982                 cifs_max_pending = 2;
 983                 cFYI(1,("cifs_max_pending set to min of 2"));
 984         } else if(cifs_max_pending > 256) {
 985                 cifs_max_pending = 256;
 986                 cFYI(1,("cifs_max_pending set to max of 256"));
 987         }
 988
 989         rc = cifs_init_inodecache();
 990         if (!rc) {
 991                 rc = cifs_init_mids();
 992                 if (!rc) {
 993                         rc = cifs_init_request_bufs();
 994                         if (!rc) {
 995                                 rc = register_filesystem(&cifs_fs_type);
 996                                 if (!rc) {
 997                                         rc = (int)kernel_thread(cifs_oplock_thread, NULL,
 998                                                 CLONE_FS | CLONE_FILES | CLONE_VM);
 999                                         if(rc > 0) {
1000                                                 rc = (int)kernel_thread(cifs_dnotify_thread, NULL,
1001                                                         CLONE_FS | CLONE_FILES | CLONE_VM);
1002                                                 if(rc > 0)
1003                                                         return 0;
1004                                                 else
1005                                                         cERROR(1,("error %d create dnotify thread", rc));
1006                                         } else {
1007                                                 cERROR(1,("error %d create oplock thread",rc));
1008                                         }
1009                                 }
1010                                 cifs_destroy_request_bufs();
1011                         }
1012                         cifs_destroy_mids();
1013                 }
1014                 cifs_destroy_inodecache();
1015         }
1016 #ifdef CONFIG_PROC_FS
1017         cifs_proc_clean();
1018 #endif
1019         return rc;
1020 }
1021
1022 static void __exit
1023 exit_cifs(void)
1024 {
1025         cFYI(0, ("In unregister ie exit_cifs"));
1026 #ifdef CONFIG_PROC_FS
1027         cifs_proc_clean();
1028 #endif
1029         unregister_filesystem(&cifs_fs_type);
1030         cifs_destroy_inodecache();
1031         cifs_destroy_mids();
1032         cifs_destroy_request_bufs();
1033         if(oplockThread) {
1034                 send_sig(SIGTERM, oplockThread, 1);
1035                 wait_for_completion(&cifs_oplock_exited);
1036         }
1037         if(dnotifyThread) {
1038                 send_sig(SIGTERM, dnotifyThread, 1);
1039                 wait_for_completion(&cifs_dnotify_exited);
1040         }
1041 }
1042
1043 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1044 MODULE_LICENSE("GPL");          /* combination of LGPL + GPL source behaves as GPL */
1045 MODULE_DESCRIPTION
1046     ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1047 MODULE_VERSION(CIFS_VERSION);
1048 module_init(init_cifs)
1049 module_exit(exit_cifs)