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