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 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 static 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). "
  71                                  "Default: 16384 Range: 8192 to 130048");
  72 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  73 module_param(cifs_min_rcv, int, 0);
  74 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  75                                 "1 to 64");
  76 unsigned int cifs_min_small = 30;
  77 module_param(cifs_min_small, int, 0);
  78 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  79                                  "Range: 2 to 256");
  80 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  81 module_param(cifs_max_pending, int, 0);
  82 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  83                                    "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                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) ||
 312                            !(cifs_sb->tcon->unix_ext))
 313                                 seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
 314                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
 315                            !(cifs_sb->tcon->unix_ext))
 316                                 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
 317                 }
 318                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 319                         seq_printf(s, ",posixpaths");
 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                 rc = -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                 cFYI(1, ("wake up tasks now - umount begin not complete"));
 453                 wake_up_all(&tcon->ses->server->request_q);
 454                 wake_up_all(&tcon->ses->server->response_q);
 455                 msleep(1); /* yield */
 456                 /* we have to kick the requests once more */
 457                 wake_up_all(&tcon->ses->server->response_q);
 458                 msleep(1);
 459         }
 460 /* BB FIXME - finish add checks for tidStatus BB */
 461
 462         return;
 463 }
 464
 465 #ifdef CONFIG_CIFS_STATS2
 466 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 467 {
 468         /* BB FIXME */
 469         return 0;
 470 }
 471 #endif
 472
 473 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 474 {
 475         *flags |= MS_NODIRATIME;
 476         return 0;
 477 }
 478
 479 static const struct super_operations cifs_super_ops = {
 480         .read_inode = cifs_read_inode,
 481         .put_super = cifs_put_super,
 482         .statfs = cifs_statfs,
 483         .alloc_inode = cifs_alloc_inode,
 484         .destroy_inode = cifs_destroy_inode,
 485 /*      .drop_inode         = generic_delete_inode,
 486         .delete_inode   = cifs_delete_inode,  */  /* Do not need above two
 487         functions unless later we add lazy close of inodes or unless the
 488         kernel forgets to call us with the same number of releases (closes)
 489         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         .splice_read = generic_file_splice_read,
 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         .splice_read = generic_file_splice_read,
 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         .splice_read = generic_file_splice_read,
 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         .splice_read = generic_file_splice_read,
 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(struct kmem_cache *cachep, void *inode)
 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);
 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);
 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);
 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);
 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);
 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         set_freezable();
 856         do {
 857                 if (try_to_freeze())
 858                         continue;
 859
 860                 spin_lock(&GlobalMid_Lock);
 861                 if (list_empty(&GlobalOplock_Q)) {
 862                         spin_unlock(&GlobalMid_Lock);
 863                         set_current_state(TASK_INTERRUPTIBLE);
 864                         schedule_timeout(39*HZ);
 865                 } else {
 866                         oplock_item = list_entry(GlobalOplock_Q.next,
 867                                 struct oplock_q_entry, qhead);
 868                         if (oplock_item) {
 869                                 cFYI(1, ("found oplock item to write out"));
 870                                 pTcon = oplock_item->tcon;
 871                                 inode = oplock_item->pinode;
 872                                 netfid = oplock_item->netfid;
 873                                 spin_unlock(&GlobalMid_Lock);
 874                                 DeleteOplockQEntry(oplock_item);
 875                                 /* can not grab inode sem here since it would
 876                                 deadlock when oplock received on delete
 877                                 since vfs_unlink holds the i_mutex across
 878                                 the call */
 879                                 /* mutex_lock(&inode->i_mutex);*/
 880                                 if (S_ISREG(inode->i_mode)) {
 881                                         rc =
 882                                            filemap_fdatawrite(inode->i_mapping);
 883                                         if (CIFS_I(inode)->clientCanCacheRead
 884                                                                          == 0) {
 885                                                 filemap_fdatawait(inode->i_mapping);
 886                                                 invalidate_remote_inode(inode);
 887                                         }
 888                                 } else
 889                                         rc = 0;
 890                                 /* mutex_unlock(&inode->i_mutex);*/
 891                                 if (rc)
 892                                         CIFS_I(inode)->write_behind_rc = rc;
 893                                 cFYI(1, ("Oplock flush inode %p rc %d",
 894                                         inode, rc));
 895
 896                                 /* releasing stale oplock after recent reconnect
 897                                 of smb session using a now incorrect file
 898                                 handle is not a data integrity issue but do
 899                                 not bother sending an oplock release if session
 900                                 to server still is disconnected since oplock
 901                                 already released by the server in that case */
 902                                 if (pTcon->tidStatus != CifsNeedReconnect) {
 903                                     rc = CIFSSMBLock(0, pTcon, netfid,
 904                                             0 /* len */ , 0 /* offset */, 0,
 905                                             0, LOCKING_ANDX_OPLOCK_RELEASE,
 906                                             0 /* wait flag */);
 907                                         cFYI(1, ("Oplock release rc = %d", rc));
 908                                 }
 909                         } else
 910                                 spin_unlock(&GlobalMid_Lock);
 911                         set_current_state(TASK_INTERRUPTIBLE);
 912                         schedule_timeout(1);  /* yield in case q were corrupt */
 913                 }
 914         } while (!kthread_should_stop());
 915
 916         return 0;
 917 }
 918
 919 static int cifs_dnotify_thread(void *dummyarg)
 920 {
 921         struct list_head *tmp;
 922         struct cifsSesInfo *ses;
 923
 924         do {
 925                 if (try_to_freeze())
 926                         continue;
 927                 set_current_state(TASK_INTERRUPTIBLE);
 928                 schedule_timeout(15*HZ);
 929                 read_lock(&GlobalSMBSeslock);
 930                 /* check if any stuck requests that need
 931                    to be woken up and wakeq so the
 932                    thread can wake up and error out */
 933                 list_for_each(tmp, &GlobalSMBSessionList) {
 934                         ses = list_entry(tmp, struct cifsSesInfo,
 935                                 cifsSessionList);
 936                         if (ses && ses->server &&
 937                              atomic_read(&ses->server->inFlight))
 938                                 wake_up_all(&ses->server->response_q);
 939                 }
 940                 read_unlock(&GlobalSMBSeslock);
 941         } while (!kthread_should_stop());
 942
 943         return 0;
 944 }
 945
 946 static int __init
 947 init_cifs(void)
 948 {
 949         int rc = 0;
 950 #ifdef CONFIG_PROC_FS
 951         cifs_proc_init();
 952 #endif
 953 /*      INIT_LIST_HEAD(&GlobalServerList);*/    /* BB not implemented yet */
 954         INIT_LIST_HEAD(&GlobalSMBSessionList);
 955         INIT_LIST_HEAD(&GlobalTreeConnectionList);
 956         INIT_LIST_HEAD(&GlobalOplock_Q);
 957 #ifdef CONFIG_CIFS_EXPERIMENTAL
 958         INIT_LIST_HEAD(&GlobalDnotifyReqList);
 959         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
 960 #endif
 961 /*
 962  *  Initialize Global counters
 963  */
 964         atomic_set(&sesInfoAllocCount, 0);
 965         atomic_set(&tconInfoAllocCount, 0);
 966         atomic_set(&tcpSesAllocCount, 0);
 967         atomic_set(&tcpSesReconnectCount, 0);
 968         atomic_set(&tconInfoReconnectCount, 0);
 969
 970         atomic_set(&bufAllocCount, 0);
 971         atomic_set(&smBufAllocCount, 0);
 972 #ifdef CONFIG_CIFS_STATS2
 973         atomic_set(&totBufAllocCount, 0);
 974         atomic_set(&totSmBufAllocCount, 0);
 975 #endif /* CONFIG_CIFS_STATS2 */
 976
 977         atomic_set(&midCount, 0);
 978         GlobalCurrentXid = 0;
 979         GlobalTotalActiveXid = 0;
 980         GlobalMaxActiveXid = 0;
 981         memset(Local_System_Name, 0, 15);
 982         rwlock_init(&GlobalSMBSeslock);
 983         spin_lock_init(&GlobalMid_Lock);
 984
 985         if (cifs_max_pending < 2) {
 986                 cifs_max_pending = 2;
 987                 cFYI(1, ("cifs_max_pending set to min of 2"));
 988         } else if (cifs_max_pending > 256) {
 989                 cifs_max_pending = 256;
 990                 cFYI(1, ("cifs_max_pending set to max of 256"));
 991         }
 992
 993         rc = cifs_init_inodecache();
 994         if (rc)
 995                 goto out_clean_proc;
 996
 997         rc = cifs_init_mids();
 998         if (rc)
 999                 goto out_destroy_inodecache;
1000
1001         rc = cifs_init_request_bufs();
1002         if (rc)
1003                 goto out_destroy_mids;
1004
1005         rc = register_filesystem(&cifs_fs_type);
1006         if (rc)
1007                 goto out_destroy_request_bufs;
1008
1009         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1010         if (IS_ERR(oplockThread)) {
1011                 rc = PTR_ERR(oplockThread);
1012                 cERROR(1, ("error %d create oplock thread", rc));
1013                 goto out_unregister_filesystem;
1014         }
1015
1016         dnotifyThread = kthread_run(cifs_dnotify_thread, NULL, "cifsdnotifyd");
1017         if (IS_ERR(dnotifyThread)) {
1018                 rc = PTR_ERR(dnotifyThread);
1019                 cERROR(1, ("error %d create dnotify thread", rc));
1020                 goto out_stop_oplock_thread;
1021         }
1022
1023         return 0;
1024
1025  out_stop_oplock_thread:
1026         kthread_stop(oplockThread);
1027  out_unregister_filesystem:
1028         unregister_filesystem(&cifs_fs_type);
1029  out_destroy_request_bufs:
1030         cifs_destroy_request_bufs();
1031  out_destroy_mids:
1032         cifs_destroy_mids();
1033  out_destroy_inodecache:
1034         cifs_destroy_inodecache();
1035  out_clean_proc:
1036 #ifdef CONFIG_PROC_FS
1037         cifs_proc_clean();
1038 #endif
1039         return rc;
1040 }
1041
1042 static void __exit
1043 exit_cifs(void)
1044 {
1045         cFYI(0, ("exit_cifs"));
1046 #ifdef CONFIG_PROC_FS
1047         cifs_proc_clean();
1048 #endif
1049         unregister_filesystem(&cifs_fs_type);
1050         cifs_destroy_inodecache();
1051         cifs_destroy_mids();
1052         cifs_destroy_request_bufs();
1053         kthread_stop(oplockThread);
1054         kthread_stop(dnotifyThread);
1055 }
1056
1057 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1058 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1059 MODULE_DESCRIPTION
1060     ("VFS to access servers complying with the SNIA CIFS Specification "
1061      "e.g. Samba and Windows");
1062 MODULE_VERSION(CIFS_VERSION);
1063 module_init(init_cifs)
1064 module_exit(exit_cifs)