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         kmem_cache_destroy(cifs_inode_cachep);
 703 }
 704
 705 static int
 706 cifs_init_request_bufs(void)
 707 {
 708         if(CIFSMaxBufSize < 8192) {
 709         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 710         Unicode path name has to fit in any SMB/CIFS path based frames */
 711                 CIFSMaxBufSize = 8192;
 712         } else if (CIFSMaxBufSize > 1024*127) {
 713                 CIFSMaxBufSize = 1024 * 127;
 714         } else {
 715                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 716         }
 717 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 718         cifs_req_cachep = kmem_cache_create("cifs_request",
 719                                             CIFSMaxBufSize +
 720                                             MAX_CIFS_HDR_SIZE, 0,
 721                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
 722         if (cifs_req_cachep == NULL)
 723                 return -ENOMEM;
 724
 725         if(cifs_min_rcv < 1)
 726                 cifs_min_rcv = 1;
 727         else if (cifs_min_rcv > 64) {
 728                 cifs_min_rcv = 64;
 729                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
 730         }
 731
 732         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 733                                                   cifs_req_cachep);
 734
 735         if(cifs_req_poolp == NULL) {
 736                 kmem_cache_destroy(cifs_req_cachep);
 737                 return -ENOMEM;
 738         }
 739         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 740         almost all handle based requests (but not write response, nor is it
 741         sufficient for path based requests).  A smaller size would have
 742         been more efficient (compacting multiple slab items on one 4k page)
 743         for the case in which debug was on, but this larger size allows
 744         more SMBs to use small buffer alloc and is still much more
 745         efficient to alloc 1 per page off the slab compared to 17K (5page)
 746         alloc of large cifs buffers even when page debugging is on */
 747         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 748                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 749                         NULL, NULL);
 750         if (cifs_sm_req_cachep == NULL) {
 751                 mempool_destroy(cifs_req_poolp);
 752                 kmem_cache_destroy(cifs_req_cachep);
 753                 return -ENOMEM;
 754         }
 755
 756         if(cifs_min_small < 2)
 757                 cifs_min_small = 2;
 758         else if (cifs_min_small > 256) {
 759                 cifs_min_small = 256;
 760                 cFYI(1,("cifs_min_small set to maximum (256)"));
 761         }
 762
 763         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 764                                                      cifs_sm_req_cachep);
 765
 766         if(cifs_sm_req_poolp == NULL) {
 767                 mempool_destroy(cifs_req_poolp);
 768                 kmem_cache_destroy(cifs_req_cachep);
 769                 kmem_cache_destroy(cifs_sm_req_cachep);
 770                 return -ENOMEM;
 771         }
 772
 773         return 0;
 774 }
 775
 776 static void
 777 cifs_destroy_request_bufs(void)
 778 {
 779         mempool_destroy(cifs_req_poolp);
 780         kmem_cache_destroy(cifs_req_cachep);
 781         mempool_destroy(cifs_sm_req_poolp);
 782         kmem_cache_destroy(cifs_sm_req_cachep);
 783 }
 784
 785 static int
 786 cifs_init_mids(void)
 787 {
 788         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 789                                 sizeof (struct mid_q_entry), 0,
 790                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 791         if (cifs_mid_cachep == NULL)
 792                 return -ENOMEM;
 793
 794         /* 3 is a reasonable minimum number of simultaneous operations */
 795         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 796         if(cifs_mid_poolp == NULL) {
 797                 kmem_cache_destroy(cifs_mid_cachep);
 798                 return -ENOMEM;
 799         }
 800
 801         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 802                                 sizeof (struct oplock_q_entry), 0,
 803                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 804         if (cifs_oplock_cachep == NULL) {
 805                 kmem_cache_destroy(cifs_mid_cachep);
 806                 mempool_destroy(cifs_mid_poolp);
 807                 return -ENOMEM;
 808         }
 809
 810         return 0;
 811 }
 812
 813 static void
 814 cifs_destroy_mids(void)
 815 {
 816         mempool_destroy(cifs_mid_poolp);
 817         kmem_cache_destroy(cifs_mid_cachep);
 818         kmem_cache_destroy(cifs_oplock_cachep);
 819 }
 820
 821 static int cifs_oplock_thread(void * dummyarg)
 822 {
 823         struct oplock_q_entry * oplock_item;
 824         struct cifsTconInfo *pTcon;
 825         struct inode * inode;
 826         __u16  netfid;
 827         int rc;
 828
 829         do {
 830                 if (try_to_freeze())
 831                         continue;
 832
 833                 spin_lock(&GlobalMid_Lock);
 834                 if(list_empty(&GlobalOplock_Q)) {
 835                         spin_unlock(&GlobalMid_Lock);
 836                         set_current_state(TASK_INTERRUPTIBLE);
 837                         schedule_timeout(39*HZ);
 838                 } else {
 839                         oplock_item = list_entry(GlobalOplock_Q.next,
 840                                 struct oplock_q_entry, qhead);
 841                         if(oplock_item) {
 842                                 cFYI(1,("found oplock item to write out"));
 843                                 pTcon = oplock_item->tcon;
 844                                 inode = oplock_item->pinode;
 845                                 netfid = oplock_item->netfid;
 846                                 spin_unlock(&GlobalMid_Lock);
 847                                 DeleteOplockQEntry(oplock_item);
 848                                 /* can not grab inode sem here since it would
 849                                 deadlock when oplock received on delete
 850                                 since vfs_unlink holds the i_mutex across
 851                                 the call */
 852                                 /* mutex_lock(&inode->i_mutex);*/
 853                                 if (S_ISREG(inode->i_mode)) {
 854                                         rc = filemap_fdatawrite(inode->i_mapping);
 855                                         if(CIFS_I(inode)->clientCanCacheRead == 0) {
 856                                                 filemap_fdatawait(inode->i_mapping);
 857                                                 invalidate_remote_inode(inode);
 858                                         }
 859                                 } else
 860                                         rc = 0;
 861                                 /* mutex_unlock(&inode->i_mutex);*/
 862                                 if (rc)
 863                                         CIFS_I(inode)->write_behind_rc = rc;
 864                                 cFYI(1,("Oplock flush inode %p rc %d",inode,rc));
 865
 866                                 /* releasing a stale oplock after recent reconnection
 867                                 of smb session using a now incorrect file
 868                                 handle is not a data integrity issue but do
 869                                 not bother sending an oplock release if session
 870                                 to server still is disconnected since oplock
 871                                 already released by the server in that case */
 872                                 if(pTcon->tidStatus != CifsNeedReconnect) {
 873                                     rc = CIFSSMBLock(0, pTcon, netfid,
 874                                             0 /* len */ , 0 /* offset */, 0,
 875                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
 876                                             0 /* wait flag */);
 877                                         cFYI(1,("Oplock release rc = %d ",rc));
 878                                 }
 879                         } else
 880                                 spin_unlock(&GlobalMid_Lock);
 881                         set_current_state(TASK_INTERRUPTIBLE);
 882                         schedule_timeout(1);  /* yield in case q were corrupt */
 883                 }
 884         } while (!kthread_should_stop());
 885
 886         return 0;
 887 }
 888
 889 static int cifs_dnotify_thread(void * dummyarg)
 890 {
 891         struct list_head *tmp;
 892         struct cifsSesInfo *ses;
 893
 894         do {
 895                 if (try_to_freeze())
 896                         continue;
 897                 set_current_state(TASK_INTERRUPTIBLE);
 898                 schedule_timeout(15*HZ);
 899                 read_lock(&GlobalSMBSeslock);
 900                 /* check if any stuck requests that need
 901                    to be woken up and wakeq so the
 902                    thread can wake up and error out */
 903                 list_for_each(tmp, &GlobalSMBSessionList) {
 904                         ses = list_entry(tmp, struct cifsSesInfo,
 905                                 cifsSessionList);
 906                         if(ses && ses->server &&
 907                              atomic_read(&ses->server->inFlight))
 908                                 wake_up_all(&ses->server->response_q);
 909                 }
 910                 read_unlock(&GlobalSMBSeslock);
 911         } while (!kthread_should_stop());
 912
 913         return 0;
 914 }
 915
 916 static int __init
 917 init_cifs(void)
 918 {
 919         int rc = 0;
 920 #ifdef CONFIG_PROC_FS
 921         cifs_proc_init();
 922 #endif
 923         INIT_LIST_HEAD(&GlobalServerList);      /* BB not implemented yet */
 924         INIT_LIST_HEAD(&GlobalSMBSessionList);
 925         INIT_LIST_HEAD(&GlobalTreeConnectionList);
 926         INIT_LIST_HEAD(&GlobalOplock_Q);
 927 #ifdef CONFIG_CIFS_EXPERIMENTAL
 928         INIT_LIST_HEAD(&GlobalDnotifyReqList);
 929         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
 930 #endif
 931 /*
 932  *  Initialize Global counters
 933  */
 934         atomic_set(&sesInfoAllocCount, 0);
 935         atomic_set(&tconInfoAllocCount, 0);
 936         atomic_set(&tcpSesAllocCount,0);
 937         atomic_set(&tcpSesReconnectCount, 0);
 938         atomic_set(&tconInfoReconnectCount, 0);
 939
 940         atomic_set(&bufAllocCount, 0);
 941         atomic_set(&smBufAllocCount, 0);
 942 #ifdef CONFIG_CIFS_STATS2
 943         atomic_set(&totBufAllocCount, 0);
 944         atomic_set(&totSmBufAllocCount, 0);
 945 #endif /* CONFIG_CIFS_STATS2 */
 946
 947         atomic_set(&midCount, 0);
 948         GlobalCurrentXid = 0;
 949         GlobalTotalActiveXid = 0;
 950         GlobalMaxActiveXid = 0;
 951         rwlock_init(&GlobalSMBSeslock);
 952         spin_lock_init(&GlobalMid_Lock);
 953
 954         if(cifs_max_pending < 2) {
 955                 cifs_max_pending = 2;
 956                 cFYI(1,("cifs_max_pending set to min of 2"));
 957         } else if(cifs_max_pending > 256) {
 958                 cifs_max_pending = 256;
 959                 cFYI(1,("cifs_max_pending set to max of 256"));
 960         }
 961
 962         rc = cifs_init_inodecache();
 963         if (rc)
 964                 goto out_clean_proc;
 965
 966         rc = cifs_init_mids();
 967         if (rc)
 968                 goto out_destroy_inodecache;
 969
 970         rc = cifs_init_request_bufs();
 971         if (rc)
 972                 goto out_destroy_mids;
 973
 974         rc = register_filesystem(&cifs_fs_type);
 975         if (rc)
 976                 goto out_destroy_request_bufs;
 977
 978         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
 979         if (IS_ERR(oplockThread)) {
 980                 rc = PTR_ERR(oplockThread);
 981                 cERROR(1,("error %d create oplock thread", rc));
 982                 goto out_unregister_filesystem;
 983         }
 984
 985         dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
 986         if (IS_ERR(dnotifyThread)) {
 987                 rc = PTR_ERR(dnotifyThread);
 988                 cERROR(1,("error %d create dnotify thread", rc));
 989                 goto out_stop_oplock_thread;
 990         }
 991
 992         return 0;
 993
 994  out_stop_oplock_thread:
 995         kthread_stop(oplockThread);
 996  out_unregister_filesystem:
 997         unregister_filesystem(&cifs_fs_type);
 998  out_destroy_request_bufs:
 999         cifs_destroy_request_bufs();
1000  out_destroy_mids:
1001         cifs_destroy_mids();
1002  out_destroy_inodecache:
1003         cifs_destroy_inodecache();
1004  out_clean_proc:
1005 #ifdef CONFIG_PROC_FS
1006         cifs_proc_clean();
1007 #endif
1008         return rc;
1009 }
1010
1011 static void __exit
1012 exit_cifs(void)
1013 {
1014         cFYI(0, ("In unregister ie exit_cifs"));
1015 #ifdef CONFIG_PROC_FS
1016         cifs_proc_clean();
1017 #endif
1018         unregister_filesystem(&cifs_fs_type);
1019         cifs_destroy_inodecache();
1020         cifs_destroy_mids();
1021         cifs_destroy_request_bufs();
1022         kthread_stop(oplockThread);
1023         kthread_stop(dnotifyThread);
1024 }
1025
1026 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1027 MODULE_LICENSE("GPL");          /* combination of LGPL + GPL source behaves as GPL */
1028 MODULE_DESCRIPTION
1029     ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1030 MODULE_VERSION(CIFS_VERSION);
1031 module_init(init_cifs)
1032 module_exit(exit_cifs)