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