fs/cifs/cifsfs.c

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