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