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