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 /* BB add prepath to mount options displayed */
 291                         seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
 292                         if (cifs_sb->tcon->ses) {
 293                                 if (cifs_sb->tcon->ses->userName)
 294                                         seq_printf(s, ",username=%s",
 295                                            cifs_sb->tcon->ses->userName);
 296                                 if(cifs_sb->tcon->ses->domainName)
 297                                         seq_printf(s, ",domain=%s",
 298                                            cifs_sb->tcon->ses->domainName);
 299                         }
 300                 }
 301                 seq_printf(s, ",rsize=%d",cifs_sb->rsize);
 302                 seq_printf(s, ",wsize=%d",cifs_sb->wsize);
 303         }
 304         return 0;
 305 }
 306
 307 #ifdef CONFIG_CIFS_QUOTA
 308 int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
 309                 struct fs_disk_quota * pdquota)
 310 {
 311         int xid;
 312         int rc = 0;
 313         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 314         struct cifsTconInfo *pTcon;
 315
 316         if(cifs_sb)
 317                 pTcon = cifs_sb->tcon;
 318         else
 319                 return -EIO;
 320
 321
 322         xid = GetXid();
 323         if(pTcon) {
 324                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 325         } else {
 326                 return -EIO;
 327         }
 328
 329         FreeXid(xid);
 330         return rc;
 331 }
 332
 333 int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
 334                 struct fs_disk_quota * pdquota)
 335 {
 336         int xid;
 337         int rc = 0;
 338         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 339         struct cifsTconInfo *pTcon;
 340
 341         if(cifs_sb)
 342                 pTcon = cifs_sb->tcon;
 343         else
 344                 return -EIO;
 345
 346         xid = GetXid();
 347         if(pTcon) {
 348                 cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
 349         } else {
 350                 rc = -EIO;
 351         }
 352
 353         FreeXid(xid);
 354         return rc;
 355 }
 356
 357 int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
 358 {
 359         int xid;
 360         int rc = 0;
 361         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 362         struct cifsTconInfo *pTcon;
 363
 364         if(cifs_sb)
 365                 pTcon = cifs_sb->tcon;
 366         else
 367                 return -EIO;
 368
 369         xid = GetXid();
 370         if(pTcon) {
 371                 cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
 372         } else {
 373                 rc = -EIO;
 374         }
 375
 376         FreeXid(xid);
 377         return rc;
 378 }
 379
 380 int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
 381 {
 382         int xid;
 383         int rc = 0;
 384         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 385         struct cifsTconInfo *pTcon;
 386
 387         if(cifs_sb) {
 388                 pTcon = cifs_sb->tcon;
 389         } else {
 390                 return -EIO;
 391         }
 392         xid = GetXid();
 393         if(pTcon) {
 394                 cFYI(1,("pqstats %p",qstats));
 395         } else {
 396                 rc = -EIO;
 397         }
 398
 399         FreeXid(xid);
 400         return rc;
 401 }
 402
 403 static struct quotactl_ops cifs_quotactl_ops = {
 404         .set_xquota     = cifs_xquota_set,
 405         .get_xquota     = cifs_xquota_set,
 406         .set_xstate     = cifs_xstate_set,
 407         .get_xstate     = cifs_xstate_get,
 408 };
 409 #endif
 410
 411 static void cifs_umount_begin(struct vfsmount * vfsmnt, int flags)
 412 {
 413         struct cifs_sb_info *cifs_sb;
 414         struct cifsTconInfo * tcon;
 415
 416         if (!(flags & MNT_FORCE))
 417                 return;
 418         cifs_sb = CIFS_SB(vfsmnt->mnt_sb);
 419         if(cifs_sb == NULL)
 420                 return;
 421
 422         tcon = cifs_sb->tcon;
 423         if(tcon == NULL)
 424                 return;
 425         down(&tcon->tconSem);
 426         if (atomic_read(&tcon->useCount) == 1)
 427                 tcon->tidStatus = CifsExiting;
 428         up(&tcon->tconSem);
 429
 430         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 431         /* cancel_notify_requests(tcon); */
 432         if(tcon->ses && tcon->ses->server)
 433         {
 434                 cFYI(1,("wake up tasks now - umount begin not complete"));
 435                 wake_up_all(&tcon->ses->server->request_q);
 436                 wake_up_all(&tcon->ses->server->response_q);
 437                 msleep(1); /* yield */
 438                 /* we have to kick the requests once more */
 439                 wake_up_all(&tcon->ses->server->response_q);
 440                 msleep(1);
 441         }
 442 /* BB FIXME - finish add checks for tidStatus BB */
 443
 444         return;
 445 }
 446
 447 #ifdef CONFIG_CIFS_STATS2
 448 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 449 {
 450         /* BB FIXME */
 451         return 0;
 452 }
 453 #endif
 454
 455 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 456 {
 457         *flags |= MS_NODIRATIME;
 458         return 0;
 459 }
 460
 461 static const struct super_operations cifs_super_ops = {
 462         .read_inode = cifs_read_inode,
 463         .put_super = cifs_put_super,
 464         .statfs = cifs_statfs,
 465         .alloc_inode = cifs_alloc_inode,
 466         .destroy_inode = cifs_destroy_inode,
 467 /*      .drop_inode         = generic_delete_inode,
 468         .delete_inode   = cifs_delete_inode,  *//* Do not need the above two functions
 469    unless later we add lazy close of inodes or unless the kernel forgets to call
 470    us with the same number of releases (closes) as opens */
 471         .show_options = cifs_show_options,
 472         .umount_begin   = cifs_umount_begin,
 473         .remount_fs = cifs_remount,
 474 #ifdef CONFIG_CIFS_STATS2
 475         .show_stats = cifs_show_stats,
 476 #endif
 477 };
 478
 479 static int
 480 cifs_get_sb(struct file_system_type *fs_type,
 481             int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 482 {
 483         int rc;
 484         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
 485
 486         cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
 487
 488         if (IS_ERR(sb))
 489                 return PTR_ERR(sb);
 490
 491         sb->s_flags = flags;
 492
 493         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
 494         if (rc) {
 495                 up_write(&sb->s_umount);
 496                 deactivate_super(sb);
 497                 return rc;
 498         }
 499         sb->s_flags |= MS_ACTIVE;
 500         return simple_set_mnt(mnt, sb);
 501 }
 502
 503 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 504                                    unsigned long nr_segs, loff_t pos)
 505 {
 506         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 507         ssize_t written;
 508
 509         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
 510         if (!CIFS_I(inode)->clientCanCacheAll)
 511                 filemap_fdatawrite(inode->i_mapping);
 512         return written;
 513 }
 514
 515 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 516 {
 517         /* origin == SEEK_END => we must revalidate the cached file length */
 518         if (origin == SEEK_END) {
 519                 int retval;
 520
 521                 /* some applications poll for the file length in this strange
 522                    way so we must seek to end on non-oplocked files by
 523                    setting the revalidate time to zero */
 524                 if(file->f_path.dentry->d_inode)
 525                         CIFS_I(file->f_path.dentry->d_inode)->time = 0;
 526
 527                 retval = cifs_revalidate(file->f_path.dentry);
 528                 if (retval < 0)
 529                         return (loff_t)retval;
 530         }
 531         return remote_llseek(file, offset, origin);
 532 }
 533
 534 static struct file_system_type cifs_fs_type = {
 535         .owner = THIS_MODULE,
 536         .name = "cifs",
 537         .get_sb = cifs_get_sb,
 538         .kill_sb = kill_anon_super,
 539         /*  .fs_flags */
 540 };
 541 const struct inode_operations cifs_dir_inode_ops = {
 542         .create = cifs_create,
 543         .lookup = cifs_lookup,
 544         .getattr = cifs_getattr,
 545         .unlink = cifs_unlink,
 546         .link = cifs_hardlink,
 547         .mkdir = cifs_mkdir,
 548         .rmdir = cifs_rmdir,
 549         .rename = cifs_rename,
 550         .permission = cifs_permission,
 551 /*      revalidate:cifs_revalidate,   */
 552         .setattr = cifs_setattr,
 553         .symlink = cifs_symlink,
 554         .mknod   = cifs_mknod,
 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 const struct inode_operations cifs_file_inode_ops = {
 564 /*      revalidate:cifs_revalidate, */
 565         .setattr = cifs_setattr,
 566         .getattr = cifs_getattr, /* do we need this anymore? */
 567         .rename = cifs_rename,
 568         .permission = cifs_permission,
 569 #ifdef CONFIG_CIFS_XATTR
 570         .setxattr = cifs_setxattr,
 571         .getxattr = cifs_getxattr,
 572         .listxattr = cifs_listxattr,
 573         .removexattr = cifs_removexattr,
 574 #endif
 575 };
 576
 577 const struct inode_operations cifs_symlink_inode_ops = {
 578         .readlink = generic_readlink,
 579         .follow_link = cifs_follow_link,
 580         .put_link = cifs_put_link,
 581         .permission = cifs_permission,
 582         /* BB add the following two eventually */
 583         /* revalidate: cifs_revalidate,
 584            setattr:    cifs_notify_change, *//* BB do we need notify change */
 585 #ifdef CONFIG_CIFS_XATTR
 586         .setxattr = cifs_setxattr,
 587         .getxattr = cifs_getxattr,
 588         .listxattr = cifs_listxattr,
 589         .removexattr = cifs_removexattr,
 590 #endif
 591 };
 592
 593 const struct file_operations cifs_file_ops = {
 594         .read = do_sync_read,
 595         .write = do_sync_write,
 596         .aio_read = generic_file_aio_read,
 597         .aio_write = cifs_file_aio_write,
 598         .open = cifs_open,
 599         .release = cifs_close,
 600         .lock = cifs_lock,
 601         .fsync = cifs_fsync,
 602         .flush = cifs_flush,
 603         .mmap  = cifs_file_mmap,
 604         .sendfile = generic_file_sendfile,
 605         .llseek = cifs_llseek,
 606 #ifdef CONFIG_CIFS_POSIX
 607         .ioctl  = cifs_ioctl,
 608 #endif /* CONFIG_CIFS_POSIX */
 609
 610 #ifdef CONFIG_CIFS_EXPERIMENTAL
 611         .dir_notify = cifs_dir_notify,
 612 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 613 };
 614
 615 const struct file_operations cifs_file_direct_ops = {
 616         /* no mmap, no aio, no readv -
 617            BB reevaluate whether they can be done with directio, no cache */
 618         .read = cifs_user_read,
 619         .write = cifs_user_write,
 620         .open = cifs_open,
 621         .release = cifs_close,
 622         .lock = cifs_lock,
 623         .fsync = cifs_fsync,
 624         .flush = cifs_flush,
 625         .sendfile = generic_file_sendfile, /* BB removeme BB */
 626 #ifdef CONFIG_CIFS_POSIX
 627         .ioctl  = cifs_ioctl,
 628 #endif /* CONFIG_CIFS_POSIX */
 629         .llseek = cifs_llseek,
 630 #ifdef CONFIG_CIFS_EXPERIMENTAL
 631         .dir_notify = cifs_dir_notify,
 632 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 633 };
 634 const struct file_operations cifs_file_nobrl_ops = {
 635         .read = do_sync_read,
 636         .write = do_sync_write,
 637         .aio_read = generic_file_aio_read,
 638         .aio_write = cifs_file_aio_write,
 639         .open = cifs_open,
 640         .release = cifs_close,
 641         .fsync = cifs_fsync,
 642         .flush = cifs_flush,
 643         .mmap  = cifs_file_mmap,
 644         .sendfile = generic_file_sendfile,
 645         .llseek = cifs_llseek,
 646 #ifdef CONFIG_CIFS_POSIX
 647         .ioctl  = cifs_ioctl,
 648 #endif /* CONFIG_CIFS_POSIX */
 649
 650 #ifdef CONFIG_CIFS_EXPERIMENTAL
 651         .dir_notify = cifs_dir_notify,
 652 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 653 };
 654
 655 const struct file_operations cifs_file_direct_nobrl_ops = {
 656         /* no mmap, no aio, no readv -
 657            BB reevaluate whether they can be done with directio, no cache */
 658         .read = cifs_user_read,
 659         .write = cifs_user_write,
 660         .open = cifs_open,
 661         .release = cifs_close,
 662         .fsync = cifs_fsync,
 663         .flush = cifs_flush,
 664         .sendfile = generic_file_sendfile, /* BB removeme BB */
 665 #ifdef CONFIG_CIFS_POSIX
 666         .ioctl  = cifs_ioctl,
 667 #endif /* CONFIG_CIFS_POSIX */
 668         .llseek = cifs_llseek,
 669 #ifdef CONFIG_CIFS_EXPERIMENTAL
 670         .dir_notify = cifs_dir_notify,
 671 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 672 };
 673
 674 const struct file_operations cifs_dir_ops = {
 675         .readdir = cifs_readdir,
 676         .release = cifs_closedir,
 677         .read    = generic_read_dir,
 678 #ifdef CONFIG_CIFS_EXPERIMENTAL
 679         .dir_notify = cifs_dir_notify,
 680 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 681         .ioctl  = cifs_ioctl,
 682 };
 683
 684 static void
 685 cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
 686 {
 687         struct cifsInodeInfo *cifsi = inode;
 688
 689         if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
 690             SLAB_CTOR_CONSTRUCTOR) {
 691                 inode_init_once(&cifsi->vfs_inode);
 692                 INIT_LIST_HEAD(&cifsi->lockList);
 693         }
 694 }
 695
 696 static int
 697 cifs_init_inodecache(void)
 698 {
 699         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 700                                               sizeof (struct cifsInodeInfo),
 701                                               0, (SLAB_RECLAIM_ACCOUNT|
 702                                                 SLAB_MEM_SPREAD),
 703                                               cifs_init_once, NULL);
 704         if (cifs_inode_cachep == NULL)
 705                 return -ENOMEM;
 706
 707         return 0;
 708 }
 709
 710 static void
 711 cifs_destroy_inodecache(void)
 712 {
 713         kmem_cache_destroy(cifs_inode_cachep);
 714 }
 715
 716 static int
 717 cifs_init_request_bufs(void)
 718 {
 719         if(CIFSMaxBufSize < 8192) {
 720         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 721         Unicode path name has to fit in any SMB/CIFS path based frames */
 722                 CIFSMaxBufSize = 8192;
 723         } else if (CIFSMaxBufSize > 1024*127) {
 724                 CIFSMaxBufSize = 1024 * 127;
 725         } else {
 726                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 727         }
 728 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 729         cifs_req_cachep = kmem_cache_create("cifs_request",
 730                                             CIFSMaxBufSize +
 731                                             MAX_CIFS_HDR_SIZE, 0,
 732                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
 733         if (cifs_req_cachep == NULL)
 734                 return -ENOMEM;
 735
 736         if(cifs_min_rcv < 1)
 737                 cifs_min_rcv = 1;
 738         else if (cifs_min_rcv > 64) {
 739                 cifs_min_rcv = 64;
 740                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
 741         }
 742
 743         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 744                                                   cifs_req_cachep);
 745
 746         if(cifs_req_poolp == NULL) {
 747                 kmem_cache_destroy(cifs_req_cachep);
 748                 return -ENOMEM;
 749         }
 750         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 751         almost all handle based requests (but not write response, nor is it
 752         sufficient for path based requests).  A smaller size would have
 753         been more efficient (compacting multiple slab items on one 4k page)
 754         for the case in which debug was on, but this larger size allows
 755         more SMBs to use small buffer alloc and is still much more
 756         efficient to alloc 1 per page off the slab compared to 17K (5page)
 757         alloc of large cifs buffers even when page debugging is on */
 758         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 759                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 760                         NULL, NULL);
 761         if (cifs_sm_req_cachep == NULL) {
 762                 mempool_destroy(cifs_req_poolp);
 763                 kmem_cache_destroy(cifs_req_cachep);
 764                 return -ENOMEM;
 765         }
 766
 767         if(cifs_min_small < 2)
 768                 cifs_min_small = 2;
 769         else if (cifs_min_small > 256) {
 770                 cifs_min_small = 256;
 771                 cFYI(1,("cifs_min_small set to maximum (256)"));
 772         }
 773
 774         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 775                                                      cifs_sm_req_cachep);
 776
 777         if(cifs_sm_req_poolp == NULL) {
 778                 mempool_destroy(cifs_req_poolp);
 779                 kmem_cache_destroy(cifs_req_cachep);
 780                 kmem_cache_destroy(cifs_sm_req_cachep);
 781                 return -ENOMEM;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static void
 788 cifs_destroy_request_bufs(void)
 789 {
 790         mempool_destroy(cifs_req_poolp);
 791         kmem_cache_destroy(cifs_req_cachep);
 792         mempool_destroy(cifs_sm_req_poolp);
 793         kmem_cache_destroy(cifs_sm_req_cachep);
 794 }
 795
 796 static int
 797 cifs_init_mids(void)
 798 {
 799         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 800                                 sizeof (struct mid_q_entry), 0,
 801                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 802         if (cifs_mid_cachep == NULL)
 803                 return -ENOMEM;
 804
 805         /* 3 is a reasonable minimum number of simultaneous operations */
 806         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 807         if(cifs_mid_poolp == NULL) {
 808                 kmem_cache_destroy(cifs_mid_cachep);
 809                 return -ENOMEM;
 810         }
 811
 812         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 813                                 sizeof (struct oplock_q_entry), 0,
 814                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
 815         if (cifs_oplock_cachep == NULL) {
 816                 kmem_cache_destroy(cifs_mid_cachep);
 817                 mempool_destroy(cifs_mid_poolp);
 818                 return -ENOMEM;
 819         }
 820
 821         return 0;
 822 }
 823
 824 static void
 825 cifs_destroy_mids(void)
 826 {
 827         mempool_destroy(cifs_mid_poolp);
 828         kmem_cache_destroy(cifs_mid_cachep);
 829         kmem_cache_destroy(cifs_oplock_cachep);
 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         memset(Local_System_Name, 0, 15);
 963         rwlock_init(&GlobalSMBSeslock);
 964         spin_lock_init(&GlobalMid_Lock);
 965
 966         if(cifs_max_pending < 2) {
 967                 cifs_max_pending = 2;
 968                 cFYI(1,("cifs_max_pending set to min of 2"));
 969         } else if(cifs_max_pending > 256) {
 970                 cifs_max_pending = 256;
 971                 cFYI(1,("cifs_max_pending set to max of 256"));
 972         }
 973
 974         rc = cifs_init_inodecache();
 975         if (rc)
 976                 goto out_clean_proc;
 977
 978         rc = cifs_init_mids();
 979         if (rc)
 980                 goto out_destroy_inodecache;
 981
 982         rc = cifs_init_request_bufs();
 983         if (rc)
 984                 goto out_destroy_mids;
 985
 986         rc = register_filesystem(&cifs_fs_type);
 987         if (rc)
 988                 goto out_destroy_request_bufs;
 989
 990         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
 991         if (IS_ERR(oplockThread)) {
 992                 rc = PTR_ERR(oplockThread);
 993                 cERROR(1,("error %d create oplock thread", rc));
 994                 goto out_unregister_filesystem;
 995         }
 996
 997         dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
 998         if (IS_ERR(dnotifyThread)) {
 999                 rc = PTR_ERR(dnotifyThread);
1000                 cERROR(1,("error %d create dnotify thread", rc));
1001                 goto out_stop_oplock_thread;
1002         }
1003
1004         return 0;
1005
1006  out_stop_oplock_thread:
1007         kthread_stop(oplockThread);
1008  out_unregister_filesystem:
1009         unregister_filesystem(&cifs_fs_type);
1010  out_destroy_request_bufs:
1011         cifs_destroy_request_bufs();
1012  out_destroy_mids:
1013         cifs_destroy_mids();
1014  out_destroy_inodecache:
1015         cifs_destroy_inodecache();
1016  out_clean_proc:
1017 #ifdef CONFIG_PROC_FS
1018         cifs_proc_clean();
1019 #endif
1020         return rc;
1021 }
1022
1023 static void __exit
1024 exit_cifs(void)
1025 {
1026         cFYI(0, ("In unregister ie exit_cifs"));
1027 #ifdef CONFIG_PROC_FS
1028         cifs_proc_clean();
1029 #endif
1030         unregister_filesystem(&cifs_fs_type);
1031         cifs_destroy_inodecache();
1032         cifs_destroy_mids();
1033         cifs_destroy_request_bufs();
1034         kthread_stop(oplockThread);
1035         kthread_stop(dnotifyThread);
1036 }
1037
1038 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1039 MODULE_LICENSE("GPL");          /* combination of LGPL + GPL source behaves as GPL */
1040 MODULE_DESCRIPTION
1041     ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
1042 MODULE_VERSION(CIFS_VERSION);
1043 module_init(init_cifs)
1044 module_exit(exit_cifs)