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