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