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