fs/cifs/cifsfs.c

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