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