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;
 518
 519         lock_kernel();
 520
 521         sb = sget(fs_type, NULL, set_anon_super, NULL);
 522
 523         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
 524
 525         if (IS_ERR(sb)) {
 526                 unlock_kernel();
 527                 return PTR_ERR(sb);
 528         }
 529
 530         sb->s_flags = flags;
 531
 532         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
 533         if (rc) {
 534                 deactivate_locked_super(sb);
 535                 unlock_kernel();
 536                 return rc;
 537         }
 538         sb->s_flags |= MS_ACTIVE;
 539         simple_set_mnt(mnt, sb);
 540         unlock_kernel();
 541         return 0;
 542 }
 543
 544 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 545                                    unsigned long nr_segs, loff_t pos)
 546 {
 547         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 548         ssize_t written;
 549
 550         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
 551         if (!CIFS_I(inode)->clientCanCacheAll)
 552                 filemap_fdatawrite(inode->i_mapping);
 553         return written;
 554 }
 555
 556 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 557 {
 558         /* origin == SEEK_END => we must revalidate the cached file length */
 559         if (origin == SEEK_END) {
 560                 int retval;
 561
 562                 /* some applications poll for the file length in this strange
 563                    way so we must seek to end on non-oplocked files by
 564                    setting the revalidate time to zero */
 565                 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
 566
 567                 retval = cifs_revalidate_file(file);
 568                 if (retval < 0)
 569                         return (loff_t)retval;
 570         }
 571         return generic_file_llseek_unlocked(file, offset, origin);
 572 }
 573
 574 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
 575 {
 576         /* note that this is called by vfs setlease with the BKL held
 577            although I doubt that BKL is needed here in cifs */
 578         struct inode *inode = file->f_path.dentry->d_inode;
 579
 580         if (!(S_ISREG(inode->i_mode)))
 581                 return -EINVAL;
 582
 583         /* check if file is oplocked */
 584         if (((arg == F_RDLCK) &&
 585                 (CIFS_I(inode)->clientCanCacheRead)) ||
 586             ((arg == F_WRLCK) &&
 587                 (CIFS_I(inode)->clientCanCacheAll)))
 588                 return generic_setlease(file, arg, lease);
 589         else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
 590                         !CIFS_I(inode)->clientCanCacheRead)
 591                 /* If the server claims to support oplock on this
 592                    file, then we still need to check oplock even
 593                    if the local_lease mount option is set, but there
 594                    are servers which do not support oplock for which
 595                    this mount option may be useful if the user
 596                    knows that the file won't be changed on the server
 597                    by anyone else */
 598                 return generic_setlease(file, arg, lease);
 599         else
 600                 return -EAGAIN;
 601 }
 602
 603 struct file_system_type cifs_fs_type = {
 604         .owner = THIS_MODULE,
 605         .name = "cifs",
 606         .get_sb = cifs_get_sb,
 607         .kill_sb = kill_anon_super,
 608         /*  .fs_flags */
 609 };
 610 const struct inode_operations cifs_dir_inode_ops = {
 611         .create = cifs_create,
 612         .lookup = cifs_lookup,
 613         .getattr = cifs_getattr,
 614         .unlink = cifs_unlink,
 615         .link = cifs_hardlink,
 616         .mkdir = cifs_mkdir,
 617         .rmdir = cifs_rmdir,
 618         .rename = cifs_rename,
 619         .permission = cifs_permission,
 620 /*      revalidate:cifs_revalidate,   */
 621         .setattr = cifs_setattr,
 622         .symlink = cifs_symlink,
 623         .mknod   = cifs_mknod,
 624 #ifdef CONFIG_CIFS_XATTR
 625         .setxattr = cifs_setxattr,
 626         .getxattr = cifs_getxattr,
 627         .listxattr = cifs_listxattr,
 628         .removexattr = cifs_removexattr,
 629 #endif
 630 };
 631
 632 const struct inode_operations cifs_file_inode_ops = {
 633 /*      revalidate:cifs_revalidate, */
 634         .setattr = cifs_setattr,
 635         .getattr = cifs_getattr, /* do we need this anymore? */
 636         .rename = cifs_rename,
 637         .permission = cifs_permission,
 638 #ifdef CONFIG_CIFS_XATTR
 639         .setxattr = cifs_setxattr,
 640         .getxattr = cifs_getxattr,
 641         .listxattr = cifs_listxattr,
 642         .removexattr = cifs_removexattr,
 643 #endif
 644 };
 645
 646 const struct inode_operations cifs_symlink_inode_ops = {
 647         .readlink = generic_readlink,
 648         .follow_link = cifs_follow_link,
 649         .put_link = cifs_put_link,
 650         .permission = cifs_permission,
 651         /* BB add the following two eventually */
 652         /* revalidate: cifs_revalidate,
 653            setattr:    cifs_notify_change, *//* BB do we need notify change */
 654 #ifdef CONFIG_CIFS_XATTR
 655         .setxattr = cifs_setxattr,
 656         .getxattr = cifs_getxattr,
 657         .listxattr = cifs_listxattr,
 658         .removexattr = cifs_removexattr,
 659 #endif
 660 };
 661
 662 const struct file_operations cifs_file_ops = {
 663         .read = do_sync_read,
 664         .write = do_sync_write,
 665         .aio_read = generic_file_aio_read,
 666         .aio_write = cifs_file_aio_write,
 667         .open = cifs_open,
 668         .release = cifs_close,
 669         .lock = cifs_lock,
 670         .fsync = cifs_fsync,
 671         .flush = cifs_flush,
 672         .mmap  = cifs_file_mmap,
 673         .splice_read = generic_file_splice_read,
 674         .llseek = cifs_llseek,
 675 #ifdef CONFIG_CIFS_POSIX
 676         .unlocked_ioctl = cifs_ioctl,
 677 #endif /* CONFIG_CIFS_POSIX */
 678         .setlease = cifs_setlease,
 679 };
 680
 681 const struct file_operations cifs_file_direct_ops = {
 682         /* no aio, no readv -
 683            BB reevaluate whether they can be done with directio, no cache */
 684         .read = cifs_user_read,
 685         .write = cifs_user_write,
 686         .open = cifs_open,
 687         .release = cifs_close,
 688         .lock = cifs_lock,
 689         .fsync = cifs_fsync,
 690         .flush = cifs_flush,
 691         .mmap = cifs_file_mmap,
 692         .splice_read = generic_file_splice_read,
 693 #ifdef CONFIG_CIFS_POSIX
 694         .unlocked_ioctl  = cifs_ioctl,
 695 #endif /* CONFIG_CIFS_POSIX */
 696         .llseek = cifs_llseek,
 697         .setlease = cifs_setlease,
 698 };
 699 const struct file_operations cifs_file_nobrl_ops = {
 700         .read = do_sync_read,
 701         .write = do_sync_write,
 702         .aio_read = generic_file_aio_read,
 703         .aio_write = cifs_file_aio_write,
 704         .open = cifs_open,
 705         .release = cifs_close,
 706         .fsync = cifs_fsync,
 707         .flush = cifs_flush,
 708         .mmap  = cifs_file_mmap,
 709         .splice_read = generic_file_splice_read,
 710         .llseek = cifs_llseek,
 711 #ifdef CONFIG_CIFS_POSIX
 712         .unlocked_ioctl = cifs_ioctl,
 713 #endif /* CONFIG_CIFS_POSIX */
 714         .setlease = cifs_setlease,
 715 };
 716
 717 const struct file_operations cifs_file_direct_nobrl_ops = {
 718         /* no mmap, no aio, no readv -
 719            BB reevaluate whether they can be done with directio, no cache */
 720         .read = cifs_user_read,
 721         .write = cifs_user_write,
 722         .open = cifs_open,
 723         .release = cifs_close,
 724         .fsync = cifs_fsync,
 725         .flush = cifs_flush,
 726         .mmap = cifs_file_mmap,
 727         .splice_read = generic_file_splice_read,
 728 #ifdef CONFIG_CIFS_POSIX
 729         .unlocked_ioctl  = cifs_ioctl,
 730 #endif /* CONFIG_CIFS_POSIX */
 731         .llseek = cifs_llseek,
 732         .setlease = cifs_setlease,
 733 };
 734
 735 const struct file_operations cifs_dir_ops = {
 736         .readdir = cifs_readdir,
 737         .release = cifs_closedir,
 738         .read    = generic_read_dir,
 739         .unlocked_ioctl  = cifs_ioctl,
 740         .llseek = generic_file_llseek,
 741 };
 742
 743 static void
 744 cifs_init_once(void *inode)
 745 {
 746         struct cifsInodeInfo *cifsi = inode;
 747
 748         inode_init_once(&cifsi->vfs_inode);
 749         INIT_LIST_HEAD(&cifsi->lockList);
 750 }
 751
 752 static int
 753 cifs_init_inodecache(void)
 754 {
 755         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 756                                               sizeof(struct cifsInodeInfo),
 757                                               0, (SLAB_RECLAIM_ACCOUNT|
 758                                                 SLAB_MEM_SPREAD),
 759                                               cifs_init_once);
 760         if (cifs_inode_cachep == NULL)
 761                 return -ENOMEM;
 762
 763         return 0;
 764 }
 765
 766 static void
 767 cifs_destroy_inodecache(void)
 768 {
 769         kmem_cache_destroy(cifs_inode_cachep);
 770 }
 771
 772 static int
 773 cifs_init_request_bufs(void)
 774 {
 775         if (CIFSMaxBufSize < 8192) {
 776         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 777         Unicode path name has to fit in any SMB/CIFS path based frames */
 778                 CIFSMaxBufSize = 8192;
 779         } else if (CIFSMaxBufSize > 1024*127) {
 780                 CIFSMaxBufSize = 1024 * 127;
 781         } else {
 782                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 783         }
 784 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
 785         cifs_req_cachep = kmem_cache_create("cifs_request",
 786                                             CIFSMaxBufSize +
 787                                             MAX_CIFS_HDR_SIZE, 0,
 788                                             SLAB_HWCACHE_ALIGN, NULL);
 789         if (cifs_req_cachep == NULL)
 790                 return -ENOMEM;
 791
 792         if (cifs_min_rcv < 1)
 793                 cifs_min_rcv = 1;
 794         else if (cifs_min_rcv > 64) {
 795                 cifs_min_rcv = 64;
 796                 cERROR(1, "cifs_min_rcv set to maximum (64)");
 797         }
 798
 799         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 800                                                   cifs_req_cachep);
 801
 802         if (cifs_req_poolp == NULL) {
 803                 kmem_cache_destroy(cifs_req_cachep);
 804                 return -ENOMEM;
 805         }
 806         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 807         almost all handle based requests (but not write response, nor is it
 808         sufficient for path based requests).  A smaller size would have
 809         been more efficient (compacting multiple slab items on one 4k page)
 810         for the case in which debug was on, but this larger size allows
 811         more SMBs to use small buffer alloc and is still much more
 812         efficient to alloc 1 per page off the slab compared to 17K (5page)
 813         alloc of large cifs buffers even when page debugging is on */
 814         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 815                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 816                         NULL);
 817         if (cifs_sm_req_cachep == NULL) {
 818                 mempool_destroy(cifs_req_poolp);
 819                 kmem_cache_destroy(cifs_req_cachep);
 820                 return -ENOMEM;
 821         }
 822
 823         if (cifs_min_small < 2)
 824                 cifs_min_small = 2;
 825         else if (cifs_min_small > 256) {
 826                 cifs_min_small = 256;
 827                 cFYI(1, "cifs_min_small set to maximum (256)");
 828         }
 829
 830         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 831                                                      cifs_sm_req_cachep);
 832
 833         if (cifs_sm_req_poolp == NULL) {
 834                 mempool_destroy(cifs_req_poolp);
 835                 kmem_cache_destroy(cifs_req_cachep);
 836                 kmem_cache_destroy(cifs_sm_req_cachep);
 837                 return -ENOMEM;
 838         }
 839
 840         return 0;
 841 }
 842
 843 static void
 844 cifs_destroy_request_bufs(void)
 845 {
 846         mempool_destroy(cifs_req_poolp);
 847         kmem_cache_destroy(cifs_req_cachep);
 848         mempool_destroy(cifs_sm_req_poolp);
 849         kmem_cache_destroy(cifs_sm_req_cachep);
 850 }
 851
 852 static int
 853 cifs_init_mids(void)
 854 {
 855         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 856                                             sizeof(struct mid_q_entry), 0,
 857                                             SLAB_HWCACHE_ALIGN, NULL);
 858         if (cifs_mid_cachep == NULL)
 859                 return -ENOMEM;
 860
 861         /* 3 is a reasonable minimum number of simultaneous operations */
 862         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 863         if (cifs_mid_poolp == NULL) {
 864                 kmem_cache_destroy(cifs_mid_cachep);
 865                 return -ENOMEM;
 866         }
 867
 868         return 0;
 869 }
 870
 871 static void
 872 cifs_destroy_mids(void)
 873 {
 874         mempool_destroy(cifs_mid_poolp);
 875         kmem_cache_destroy(cifs_mid_cachep);
 876 }
 877
 878 static int __init
 879 init_cifs(void)
 880 {
 881         int rc = 0;
 882         cifs_proc_init();
 883         INIT_LIST_HEAD(&cifs_tcp_ses_list);
 884 #ifdef CONFIG_CIFS_EXPERIMENTAL
 885         INIT_LIST_HEAD(&GlobalDnotifyReqList);
 886         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
 887 #endif
 888 /*
 889  *  Initialize Global counters
 890  */
 891         atomic_set(&sesInfoAllocCount, 0);
 892         atomic_set(&tconInfoAllocCount, 0);
 893         atomic_set(&tcpSesAllocCount, 0);
 894         atomic_set(&tcpSesReconnectCount, 0);
 895         atomic_set(&tconInfoReconnectCount, 0);
 896
 897         atomic_set(&bufAllocCount, 0);
 898         atomic_set(&smBufAllocCount, 0);
 899 #ifdef CONFIG_CIFS_STATS2
 900         atomic_set(&totBufAllocCount, 0);
 901         atomic_set(&totSmBufAllocCount, 0);
 902 #endif /* CONFIG_CIFS_STATS2 */
 903
 904         atomic_set(&midCount, 0);
 905         GlobalCurrentXid = 0;
 906         GlobalTotalActiveXid = 0;
 907         GlobalMaxActiveXid = 0;
 908         memset(Local_System_Name, 0, 15);
 909         rwlock_init(&GlobalSMBSeslock);
 910         rwlock_init(&cifs_tcp_ses_lock);
 911         spin_lock_init(&GlobalMid_Lock);
 912
 913         if (cifs_max_pending < 2) {
 914                 cifs_max_pending = 2;
 915                 cFYI(1, "cifs_max_pending set to min of 2");
 916         } else if (cifs_max_pending > 256) {
 917                 cifs_max_pending = 256;
 918                 cFYI(1, "cifs_max_pending set to max of 256");
 919         }
 920
 921         rc = cifs_fscache_register();
 922         if (rc)
 923                 goto out;
 924
 925         rc = cifs_init_inodecache();
 926         if (rc)
 927                 goto out_clean_proc;
 928
 929         rc = cifs_init_mids();
 930         if (rc)
 931                 goto out_destroy_inodecache;
 932
 933         rc = cifs_init_request_bufs();
 934         if (rc)
 935                 goto out_destroy_mids;
 936
 937         rc = register_filesystem(&cifs_fs_type);
 938         if (rc)
 939                 goto out_destroy_request_bufs;
 940 #ifdef CONFIG_CIFS_UPCALL
 941         rc = register_key_type(&cifs_spnego_key_type);
 942         if (rc)
 943                 goto out_unregister_filesystem;
 944 #endif
 945
 946         return 0;
 947
 948 #ifdef CONFIG_CIFS_UPCALL
 949  out_unregister_filesystem:
 950         unregister_filesystem(&cifs_fs_type);
 951 #endif
 952  out_destroy_request_bufs:
 953         cifs_destroy_request_bufs();
 954  out_destroy_mids:
 955         cifs_destroy_mids();
 956  out_destroy_inodecache:
 957         cifs_destroy_inodecache();
 958  out_clean_proc:
 959         cifs_proc_clean();
 960         cifs_fscache_unregister();
 961  out:
 962         return rc;
 963 }
 964
 965 static void __exit
 966 exit_cifs(void)
 967 {
 968         cFYI(DBG2, "exit_cifs");
 969         cifs_proc_clean();
 970         cifs_fscache_unregister();
 971 #ifdef CONFIG_CIFS_DFS_UPCALL
 972         cifs_dfs_release_automount_timer();
 973 #endif
 974 #ifdef CONFIG_CIFS_UPCALL
 975         unregister_key_type(&cifs_spnego_key_type);
 976 #endif
 977         unregister_filesystem(&cifs_fs_type);
 978         cifs_destroy_inodecache();
 979         cifs_destroy_mids();
 980         cifs_destroy_request_bufs();
 981 }
 982
 983 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
 984 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
 985 MODULE_DESCRIPTION
 986     ("VFS to access servers complying with the SNIA CIFS Specification "
 987      "e.g. Samba and Windows");
 988 MODULE_VERSION(CIFS_VERSION);
 989 module_init(init_cifs)
 990 module_exit(exit_cifs)