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