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