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 <linux/freezer.h>
  38 #include "cifsfs.h"
  39 #include "cifspdu.h"
  40 #define DECLARE_GLOBALS_HERE
  41 #include "cifsglob.h"
  42 #include "cifsproto.h"
  43 #include "cifs_debug.h"
  44 #include "cifs_fs_sb.h"
  45 #include <linux/mm.h>
  46 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
  47
  48 #ifdef CONFIG_CIFS_QUOTA
  49 static struct quotactl_ops cifs_quotactl_ops;
  50 #endif
  51
  52 int cifsFYI = 0;
  53 int cifsERROR = 1;
  54 int traceSMB = 0;
  55 unsigned int oplockEnabled = 1;
  56 unsigned int experimEnabled = 0;
  57 unsigned int linuxExtEnabled = 1;
  58 unsigned int lookupCacheEnabled = 1;
  59 unsigned int multiuser_mount = 0;
  60 unsigned int extended_security = CIFSSEC_DEF;
  61 /* unsigned int ntlmv2_support = 0; */
  62 unsigned int sign_CIFS_PDUs = 1;
  63 extern struct task_struct * oplockThread; /* remove sparse warning */
  64 struct task_struct * oplockThread = NULL;
  65 extern struct task_struct * dnotifyThread; /* remove sparse warning */
  66 struct task_struct * dnotifyThread = NULL;
  67 static const struct super_operations cifs_super_ops;
  68 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  69 module_param(CIFSMaxBufSize, int, 0);
  70 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including header). Default: 16384 Range: 8192 to 130048");
  71 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  72 module_param(cifs_min_rcv, int, 0);
  73 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4 Range: 1 to 64");
  74 unsigned int cifs_min_small = 30;
  75 module_param(cifs_min_small, int, 0);
  76 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool. Default: 30 Range: 2 to 256");
  77 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  78 module_param(cifs_max_pending, int, 0);
  79 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server. Default: 50 Range: 2 to 256");
  80
  81 extern mempool_t *cifs_sm_req_poolp;
  82 extern mempool_t *cifs_req_poolp;
  83 extern mempool_t *cifs_mid_poolp;
  84
  85 extern struct kmem_cache *cifs_oplock_cachep;
  86
  87 static int
  88 cifs_read_super(struct super_block *sb, void *data,
  89                 const char *devname, int silent)
  90 {
  91         struct inode *inode;
  92         struct cifs_sb_info *cifs_sb;
  93         int rc = 0;
  94
  95         /* BB should we make this contingent on mount parm? */
  96         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
  97         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
  98         cifs_sb = CIFS_SB(sb);
  99         if(cifs_sb == NULL)
 100                 return -ENOMEM;
 101
 102         rc = cifs_mount(sb, cifs_sb, data, devname);
 103
 104         if (rc) {
 105                 if (!silent)
 106                         cERROR(1,
 107                                ("cifs_mount failed w/return code = %d", rc));
 108                 goto out_mount_failed;
 109         }
 110
 111         sb->s_magic = CIFS_MAGIC_NUMBER;
 112         sb->s_op = &cifs_super_ops;
 113 /*      if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
 114             sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 115 #ifdef CONFIG_CIFS_QUOTA
 116         sb->s_qcop = &cifs_quotactl_ops;
 117 #endif
 118         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 119         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 120         inode = iget(sb, ROOT_I);
 121
 122         if (!inode) {
 123                 rc = -ENOMEM;
 124                 goto out_no_root;
 125         }
 126
 127         sb->s_root = d_alloc_root(inode);
 128
 129         if (!sb->s_root) {
 130                 rc = -ENOMEM;
 131                 goto out_no_root;
 132         }
 133
 134         return 0;
 135
 136 out_no_root:
 137         cERROR(1, ("cifs_read_super: get root inode failed"));
 138         if (inode)
 139                 iput(inode);
 140
 141 out_mount_failed:
 142         if(cifs_sb) {
 143                 if(cifs_sb->local_nls)
 144                         unload_nls(cifs_sb->local_nls);
 145                 kfree(cifs_sb);
 146         }
 147         return rc;
 148 }
 149
 150 static void
 151 cifs_put_super(struct super_block *sb)
 152 {
 153         int rc = 0;
 154         struct cifs_sb_info *cifs_sb;
 155
 156         cFYI(1, ("In cifs_put_super"));
 157         cifs_sb = CIFS_SB(sb);
 158         if(cifs_sb == NULL) {
 159                 cFYI(1,("Empty cifs superblock info passed to unmount"));
 160                 return;
 161         }
 162         rc = cifs_umount(sb, cifs_sb);
 163         if (rc) {
 164                 cERROR(1, ("cifs_umount failed with return code %d", rc));
 165         }
 166         unload_nls(cifs_sb->local_nls);
 167         kfree(cifs_sb);
 168         return;
 169 }
 170
 171 static int
 172 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 173 {
 174         struct super_block *sb = dentry->d_sb;
 175         int xid;
 176         int rc = -EOPNOTSUPP;
 177         struct cifs_sb_info *cifs_sb;
 178         struct cifsTconInfo *pTcon;
 179
 180         xid = GetXid();
 181
 182         cifs_sb = CIFS_SB(sb);
 183         pTcon = cifs_sb->tcon;
 184
 185         buf->f_type = CIFS_MAGIC_NUMBER;
 186
 187         /* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
 188         buf->f_namelen = PATH_MAX; /* PATH_MAX may be too long - it would
 189                                       presumably be total path, but note
 190                                       that some servers (includinng Samba 3)
 191                                       have a shorter maximum path */
 192         buf->f_files = 0;       /* undefined */
 193         buf->f_ffree = 0;       /* unlimited */
 194
 195 /* BB we could add a second check for a QFS Unix capability bit */
 196 /* BB FIXME check CIFS_POSIX_EXTENSIONS Unix cap first FIXME BB */
 197     if ((pTcon->ses->capabilities & CAP_UNIX) && (CIFS_POSIX_EXTENSIONS &
 198                         le64_to_cpu(pTcon->fsUnixInfo.Capability)))
 199             rc = CIFSSMBQFSPosixInfo(xid, pTcon, buf);
 200
 201     /* Only need to call the old QFSInfo if failed
 202     on newer one */
 203     if(rc)
 204         if(pTcon->ses->capabilities & CAP_NT_SMBS)
 205                 rc = CIFSSMBQFSInfo(xid, pTcon, buf); /* not supported by OS2 */
 206
 207         /* Some old Windows servers also do not support level 103, retry with
 208            older level one if old server failed the previous call or we
 209            bypassed it because we detected that this was an older LANMAN sess */
 210         if(rc)
 211                 rc = SMBOldQFSInfo(xid, pTcon, buf);
 212         /*
 213            int f_type;
 214            __fsid_t f_fsid;
 215            int f_namelen;  */
 216         /* BB get from info in tcon struct at mount time call to QFSAttrInfo */
 217         FreeXid(xid);
 218         return 0;               /* always return success? what if volume is no
 219                                    longer available? */
 220 }
 221
 222 static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
 223 {
 224         struct cifs_sb_info *cifs_sb;
 225
 226         cifs_sb = CIFS_SB(inode->i_sb);
 227
 228         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 229                 return 0;
 230         } else /* file mode might have been restricted at mount time
 231                 on the client (above and beyond ACL on servers) for
 232                 servers which do not support setting and viewing mode bits,
 233                 so allowing client to check permissions is useful */
 234                 return generic_permission(inode, mask, NULL);
 235 }
 236
 237 static struct kmem_cache *cifs_inode_cachep;
 238 static struct kmem_cache *cifs_req_cachep;
 239 static struct kmem_cache *cifs_mid_cachep;
 240 struct kmem_cache *cifs_oplock_cachep;
 241 static struct kmem_cache *cifs_sm_req_cachep;
 242 mempool_t *cifs_sm_req_poolp;
 243 mempool_t *cifs_req_poolp;
 244 mempool_t *cifs_mid_poolp;
 245
 246 static struct inode *
 247 cifs_alloc_inode(struct super_block *sb)
 248 {
 249         struct cifsInodeInfo *cifs_inode;
 250         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 251         if (!cifs_inode)
 252                 return NULL;
 253         cifs_inode->cifsAttrs = 0x20;   /* default */
 254         atomic_set(&cifs_inode->inUse, 0);
 255         cifs_inode->time = 0;
 256         /* Until the file is open and we have gotten oplock
 257         info back from the server, can not assume caching of
 258         file data or metadata */
 259         cifs_inode->clientCanCacheRead = FALSE;
 260         cifs_inode->clientCanCacheAll = FALSE;
 261         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 262
 263         /* Can not set i_flags here - they get immediately overwritten
 264            to zero by the VFS */
 265 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
 266         INIT_LIST_HEAD(&cifs_inode->openFileList);
 267         return &cifs_inode->vfs_inode;
 268 }
 269
 270 static void
 271 cifs_destroy_inode(struct inode *inode)
 272 {
 273         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 274 }
 275
 276 /*
 277  * cifs_show_options() is for displaying mount options in /proc/mounts.
 278  * Not all settable options are displayed but most of the important
 279  * ones are.
 280  */
 281 static int
 282 cifs_show_options(struct seq_file *s, struct vfsmount *m)
 283 {
 284         struct cifs_sb_info *cifs_sb;
 285
 286         cifs_sb = CIFS_SB(m->mnt_sb);
 287
 288         if (cifs_sb) {
 289                 if (cifs_sb->tcon) {
 290                         seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
 291                         if (cifs_sb->tcon->ses) {
 292                                 if (cifs_sb->tcon->ses->userName)
 293                                         seq_printf(s, ",username=%s",
 294                                            cifs_sb->tcon->ses->userName);
 295                                 if(cifs_sb->tcon->ses->domainName)
 296                                         seq_printf(s, ",domain=%s",
 297                                            cifs_sb->tcon->ses->domainName);
 298                         }
 299                 }
 300                 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
 301                 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
 302         }
 303         return 0;
 304 }
 305
 306 #ifdef CONFIG_CIFS_QUOTA
 307 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
 308                 struct fs_disk_quota * pdquota)
 309 {
 310         int xid;
 311         int rc = 0;
 312         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 313         struct cifsTconInfo *pTcon;
 314
 315         if(cifs_sb)
 316                 pTcon = cifs_sb->tcon;
 317         else
 318                 return -EIO;
 319
 320
 321         xid = GetXid();
 322         if(pTcon) {
 323                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 324         } else {
 325                 return -EIO;
 326         }
 327
 328         FreeXid(xid);
 329         return rc;
 330 }
 331
 332 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
 333                 struct fs_disk_quota * pdquota)
 334 {
 335         int xid;
 336         int rc = 0;
 337         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 338         struct cifsTconInfo *pTcon;
 339
 340         if(cifs_sb)
 341                 pTcon = cifs_sb->tcon;
 342         else
 343                 return -EIO;
 344
 345         xid = GetXid();
 346         if(pTcon) {
 347                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 348         } else {
 349                 rc = -EIO;
 350         }
 351
 352         FreeXid(xid);
 353         return rc;
 354 }
 355
 356 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
 357 {
 358         int xid;
 359         int rc = 0;
 360         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 361         struct cifsTconInfo *pTcon;
 362
 363         if(cifs_sb)
 364                 pTcon = cifs_sb->tcon;
 365         else
 366                 return -EIO;
 367
 368         xid = GetXid();
 369         if(pTcon) {
 370                 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
 371         } else {
 372                 rc = -EIO;
 373         }
 374
 375         FreeXid(xid);
 376         return rc;
 377 }
 378
 379 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
 380 {
 381         int xid;
 382         int rc = 0;
 383         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 384         struct cifsTconInfo *pTcon;
 385
 386         if(cifs_sb) {
 387                 pTcon = cifs_sb->tcon;
 388         } else {
 389                 return -EIO;
 390         }
 391         xid = GetXid();
 392         if(pTcon) {
 393                 cFYI(1,("pqstats %p",qstats));
 394         } else {
 395                 rc = -EIO;
 396         }
 397
 398         FreeXid(xid);
 399         return rc;
 400 }
 401
 402 static struct quotactl_ops cifs_quotactl_ops = {
 403         .set_xquota     = cifs_xquota_set,
 404         .get_xquota     = cifs_xquota_set,
 405         .set_xstate     = cifs_xstate_set,
 406         .get_xstate     = cifs_xstate_get,
 407 };
 408 #endif
 409
 410 static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
 411 {
 412         struct cifs_sb_info *cifs_sb;
 413         struct cifsTconInfo * tcon;
 414
 415         if (!(flags & MNT_FORCE))
 416                 return;
 417         cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
 418         if(cifs_sb == NULL)
 419                 return;
 420
 421         tcon = cifs_sb->tcon;
 422         if(tcon == NULL)
 423                 return;
 424         down(&tcon->tconSem);
 425         if (atomic_read(&tcon->useCount) == 1)
 426                 tcon->tidStatus = CifsExiting;
 427         up(&tcon->tconSem);
 428
 429         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 430         /* cancel_notify_requests(tcon); */
 431         if(tcon->ses && tcon->ses->server)
 432         {
 433                 cFYI(1,("wake up tasks now - umount begin not complete"));
 434                 wake_up_all(&tcon->ses->server->request_q);
 435                 wake_up_all(&tcon->ses->server->response_q);
 436                 msleep(1); /* yield */
 437                 /* we have to kick the requests once more */
 438                 wake_up_all(&tcon->ses->server->response_q);
 439                 msleep(1);
 440         }
 441 /* BB FIXME - finish add checks for tidStatus BB */
 442
 443         return;
 444 }
 445
 446 #ifdef CONFIG_CIFS_STATS2
 447 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 448 {
 449         /* BB FIXME */
 450         return 0;
 451 }
 452 #endif
 453
 454 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 455 {
 456         *flags |= MS_NODIRATIME;
 457         return 0;
 458 }
 459
 460 static const struct super_operations cifs_super_ops = {
 461         .read_inode = cifs_read_inode,
 462         .put_super = cifs_put_super,
 463         .statfs = cifs_statfs,
 464         .alloc_inode = cifs_alloc_inode,
 465         .destroy_inode = cifs_destroy_inode,
 466 /*      .drop_inode         = generic_delete_inode,
 467         .delete_inode   = cifs_delete_inode,  *//* Do not need the above two functions
 468    unless later we add lazy close of inodes or unless the kernel forgets to call
 469    us with the same number of releases (closes) as opens */
 470         .show_options = cifs_show_options,
 471         .umount_begin   = cifs_umount_begin,
 472         .remount_fs = cifs_remount,
 473 #ifdef CONFIG_CIFS_STATS2
 474         .show_stats = cifs_show_stats,
 475 #endif
 476 };
 477
 478 static int
 479 cifs_get_sb(struct file_system_type *fs_type,
 480             int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 481 {
 482         int rc;
 483         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
 484
 485         cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
 486
 487         if (IS_ERR(sb))
 488                 return PTR_ERR(sb);
 489
 490         sb->s_flags = flags;
 491
 492         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
 493         if (rc) {
 494                 up_write(&sb->s_umount);
 495                 deactivate_super(sb);
 496                 return rc;
 497         }
 498         sb->s_flags |= MS_ACTIVE;
 499         return simple_set_mnt(mnt, sb);
 500 }
 501
 502 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 503                                    unsigned long nr_segs, loff_t pos)
 504 {
 505         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 506         ssize_t written;
 507
 508         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
 509         if (!CIFS_I(inode)->clientCanCacheAll)
 510                 filemap_fdatawrite(inode->i_mapping);
 511         return written;
 512 }
 513
 514 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 515 {
 516         /* origin == SEEK_END => we must revalidate the cached file length */
 517         if (origin == SEEK_END) {
 518                 int retval;
 519
 520                 /* some applications poll for the file length in this strange
 521                    way so we must seek to end on non-oplocked files by
 522                    setting the revalidate time to zero */
 523                 if(file->f_path.dentry->d_inode)
 524                         CIFS_I(file->f_path.dentry->d_inode)->time = 0;
 525
 526                 retval = cifs_revalidate(file->f_path.dentry);
 527                 if (retval < 0)
 528                         return (loff_t)retval;
 529         }
 530         return remote_llseek(file, offset, origin);
 531 }
 532
 533 static struct file_system_type cifs_fs_type = {
 534         .owner = THIS_MODULE,
 535         .name = "cifs",
 536         .get_sb = cifs_get_sb,
 537         .kill_sb = kill_anon_super,
 538         /*  .fs_flags */
 539 };
 540 const struct inode_operations cifs_dir_inode_ops = {
 541         .create = cifs_create,
 542         .lookup = cifs_lookup,
 543         .getattr = cifs_getattr,
 544         .unlink = cifs_unlink,
 545         .link = cifs_hardlink,
 546         .mkdir = cifs_mkdir,
 547         .rmdir = cifs_rmdir,
 548         .rename = cifs_rename,
 549         .permission = cifs_permission,
 550 /*      revalidate:cifs_revalidate,   */
 551         .setattr = cifs_setattr,
 552         .symlink = cifs_symlink,
 553         .mknod   = cifs_mknod,
 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 const struct inode_operations cifs_file_inode_ops = {
 563 /*      revalidate:cifs_revalidate, */
 564         .setattr = cifs_setattr,
 565         .getattr = cifs_getattr, /* do we need this anymore? */
 566         .rename = cifs_rename,
 567         .permission = cifs_permission,
 568 #ifdef CONFIG_CIFS_XATTR
 569         .setxattr = cifs_setxattr,
 570         .getxattr = cifs_getxattr,
 571         .listxattr = cifs_listxattr,
 572         .removexattr = cifs_removexattr,
 573 #endif
 574 };
 575
 576 const struct inode_operations cifs_symlink_inode_ops = {
 577         .readlink = generic_readlink,
 578         .follow_link = cifs_follow_link,
 579         .put_link = cifs_put_link,
 580         .permission = cifs_permission,
 581         /* BB add the following two eventually */
 582         /* revalidate: cifs_revalidate,
 583            setattr:    cifs_notify_change, *//* BB do we need notify change */
 584 #ifdef CONFIG_CIFS_XATTR
 585         .setxattr = cifs_setxattr,
 586         .getxattr = cifs_getxattr,
 587         .listxattr = cifs_listxattr,
 588         .removexattr = cifs_removexattr,
 589 #endif
 590 };
 591
 592 const struct file_operations cifs_file_ops = {
 593         .read = do_sync_read,
 594         .write = do_sync_write,
 595         .aio_read = generic_file_aio_read,
 596         .aio_write = cifs_file_aio_write,
 597         .open = cifs_open,
 598         .release = cifs_close,
 599         .lock = cifs_lock,
 600         .fsync = cifs_fsync,
 601         .flush = cifs_flush,
 602         .mmap  = cifs_file_mmap,
 603         .sendfile = generic_file_sendfile,
 604         .llseek = cifs_llseek,
 605 #ifdef CONFIG_CIFS_POSIX
 606         .ioctl  = cifs_ioctl,
 607 #endif /* CONFIG_CIFS_POSIX */
 608
 609 #ifdef CONFIG_CIFS_EXPERIMENTAL
 610         .dir_notify = cifs_dir_notify,
 611 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 612 };
 613
 614 const struct file_operations cifs_file_direct_ops = {
 615         /* no mmap, no aio, no readv -
 616            BB reevaluate whether they can be done with directio, no cache */
 617         .read = cifs_user_read,
 618         .write = cifs_user_write,
 619         .open = cifs_open,
 620         .release = cifs_close,
 621         .lock = cifs_lock,
 622         .fsync = cifs_fsync,
 623         .flush = cifs_flush,
 624         .sendfile = generic_file_sendfile, /* BB removeme BB */
 625 #ifdef CONFIG_CIFS_POSIX
 626         .ioctl  = cifs_ioctl,
 627 #endif /* CONFIG_CIFS_POSIX */
 628         .llseek = cifs_llseek,
 629 #ifdef CONFIG_CIFS_EXPERIMENTAL
 630         .dir_notify = cifs_dir_notify,
 631 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 632 };
 633 const struct file_operations cifs_file_nobrl_ops = {
 634         .read = do_sync_read,
 635         .write = do_sync_write,
 636         .aio_read = generic_file_aio_read,
 637         .aio_write = cifs_file_aio_write,
 638         .open = cifs_open,
 639         .release = cifs_close,
 640         .fsync = cifs_fsync,
 641         .flush = cifs_flush,
 642         .mmap  = cifs_file_mmap,
 643         .sendfile = generic_file_sendfile,
 644         .llseek = cifs_llseek,
 645 #ifdef CONFIG_CIFS_POSIX
 646         .ioctl  = cifs_ioctl,
 647 #endif /* CONFIG_CIFS_POSIX */
 648
 649 #ifdef CONFIG_CIFS_EXPERIMENTAL
 650         .dir_notify = cifs_dir_notify,
 651 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 652 };
 653
 654 const struct file_operations cifs_file_direct_nobrl_ops = {
 655         /* no mmap, no aio, no readv -
 656            BB reevaluate whether they can be done with directio, no cache */
 657         .read = cifs_user_read,
 658         .write = cifs_user_write,
 659         .open = cifs_open,
 660         .release = cifs_close,
 661         .fsync = cifs_fsync,
 662         .flush = cifs_flush,
 663         .sendfile = generic_file_sendfile, /* BB removeme BB */
 664 #ifdef CONFIG_CIFS_POSIX
 665         .ioctl  = cifs_ioctl,
 666 #endif /* CONFIG_CIFS_POSIX */
 667         .llseek = cifs_llseek,
 668 #ifdef CONFIG_CIFS_EXPERIMENTAL
 669         .dir_notify = cifs_dir_notify,
 670 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 671 };
 672
 673 const struct file_operations cifs_dir_ops = {
 674         .readdir = cifs_readdir,
 675         .release = cifs_closedir,
 676         .read    = generic_read_dir,
 677 #ifdef CONFIG_CIFS_EXPERIMENTAL
 678         .dir_notify = cifs_dir_notify,
 679 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 680         .ioctl  = cifs_ioctl,
 681 };
 682
 683 static void
 684 cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
 685 {
 686         struct cifsInodeInfo *cifsi = inode;
 687
 688         if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
 689             SLAB_CTOR_CONSTRUCTOR) {
 690                 inode_init_once(&cifsi->vfs_inode);
 691                 INIT_LIST_HEAD(&cifsi->lockList);
 692         }
 693 }
 694
 695 static int
 696 cifs_init_inodecache(void)
 697 {
 698         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 699                                               sizeof (struct cifsInodeInfo),
 700                                               0, (SLAB_RECLAIM_ACCOUNT|
 701                                                 SLAB_MEM_SPREAD),
 702                                               cifs_init_once, NULL);
 703         if (cifs_inode_cachep == NULL)
 704                 return -ENOMEM;
 705
 706         return 0;
 707 }
 708
 709 static void
 710 cifs_destroy_inodecache(void)
 711 {
 712         kmem_cache_destroy(cifs_inode_cachep);
 713 }
 714
 715 static int
 716 cifs_init_request_bufs(void)
 717 {
 718         if(CIFSMaxBufSize < 8192) {
 719         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 720         Unicode path name has to fit in any SMB/CIFS path based frames */
 721                 CIFSMaxBufSize = 8192;
 722         } else if (CIFSMaxBufSize > 1024*127) {
 723                 CIFSMaxBufSize = 1024 * 127;
 724         } else {
 725                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 726         }
 727 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 728         cifs_req_cachep = kmem_cache_create("cifs_request",
 729                                             CIFSMaxBufSize +
 730                                             MAX_CIFS_HDR_SIZE, 0,
 731                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
 732         if (cifs_req_cachep == NULL)
 733                 return -ENOMEM;
 734
 735         if(cifs_min_rcv < 1)
 736                 cifs_min_rcv = 1;
 737         else if (cifs_min_rcv > 64) {
 738                 cifs_min_rcv = 64;
 739                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
 740         }
 741
 742         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 743                                                   cifs_req_cachep);
 744
 745         if(cifs_req_poolp == NULL) {
 746                 kmem_cache_destroy(cifs_req_cachep);
 747                 return -ENOMEM;
 748         }
 749         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 750         almost all handle based requests (but not write response, nor is it
 751         sufficient for path based requests).  A smaller size would have
 752         been more efficient (compacting multiple slab items on one 4k page)
 753         for the case in which debug was on, but this larger size allows
 754         more SMBs to use small buffer alloc and is still much more
 755         efficient to alloc 1 per page off the slab compared to 17K (5page)
 756         alloc of large cifs buffers even when page debugging is on */
 757         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 758                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 759                         NULL, NULL);
 760         if (cifs_sm_req_cachep == NULL) {
 761                 mempool_destroy(cifs_req_poolp);
 762                 kmem_cache_destroy(cifs_req_cachep);
 763                 return -ENOMEM;
 764         }
 765
 766         if(cifs_min_small < 2)
 767                 cifs_min_small = 2;
 768         else if (cifs_min_small > 256) {
 769                 cifs_min_small = 256;
 770                 cFYI(1,("cifs_min_small set to maximum (256)"));
 771         }
 772
 773         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 774                                                      cifs_sm_req_cachep);
 775
 776         if(cifs_sm_req_poolp == NULL) {
 777                 mempool_destroy(cifs_req_poolp);
 778                 kmem_cache_destroy(cifs_req_cachep);
 779                 kmem_cache_destroy(cifs_sm_req_cachep);
 780                 return -ENOMEM;
 781         }
 782
 783         return 0;
 784 }
 785
 786 static void
 787 cifs_destroy_request_bufs(void)
 788 {
 789         mempool_destroy(cifs_req_poolp);
 790         kmem_cache_destroy(cifs_req_cachep);
 791         mempool_destroy(cifs_sm_req_poolp);
 792         kmem_cache_destroy(cifs_sm_req_cachep);
 793 }
 794
 795 static int
 796 cifs_init_mids(void)
 797 {
 798         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 799                                 sizeof (struct mid_q_entry), 0,
 800                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 801         if (cifs_mid_cachep == NULL)
 802                 return -ENOMEM;
 803
 804         /* 3 is a reasonable minimum number of simultaneous operations */
 805         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 806         if(cifs_mid_poolp == NULL) {
 807                 kmem_cache_destroy(cifs_mid_cachep);
 808                 return -ENOMEM;
 809         }
 810
 811         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 812                                 sizeof (struct oplock_q_entry), 0,
 813                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 814         if (cifs_oplock_cachep == NULL) {
 815                 kmem_cache_destroy(cifs_mid_cachep);
 816                 mempool_destroy(cifs_mid_poolp);
 817                 return -ENOMEM;
 818         }
 819
 820         return 0;
 821 }
 822
 823 static void
 824 cifs_destroy_mids(void)
 825 {
 826         mempool_destroy(cifs_mid_poolp);
 827         kmem_cache_destroy(cifs_mid_cachep);
 828         kmem_cache_destroy(cifs_oplock_cachep);
 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         memset(Local_System_Name, 0, 15);
 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)