fs/cifs/cifsfs.c

   1 /*
   2  *   fs/cifs/cifsfs.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   Common Internet FileSystem (CIFS) client
   8  *
   9  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 /* Note that BB means BUGBUG (ie something to fix eventually) */
  25
  26 #include <linux/module.h>
  27 #include <linux/fs.h>
  28 #include <linux/mount.h>
  29 #include <linux/slab.h>
  30 #include <linux/init.h>
  31 #include <linux/list.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/vfs.h>
  34 #include <linux/mempool.h>
  35 #include <linux/delay.h>
  36 #include <linux/kthread.h>
  37 #include <linux/freezer.h>
  38 #include <linux/smp_lock.h>
  39 #include "cifsfs.h"
  40 #include "cifspdu.h"
  41 #define DECLARE_GLOBALS_HERE
  42 #include "cifsglob.h"
  43 #include "cifsproto.h"
  44 #include "cifs_debug.h"
  45 #include "cifs_fs_sb.h"
  46 #include <linux/mm.h>
  47 #include <linux/key-type.h>
  48 #include "dns_resolve.h"
  49 #include "cifs_spnego.h"
  50 #include "fscache.h"
  51 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
  52
  53 int cifsFYI = 0;
  54 int cifsERROR = 1;
  55 int traceSMB = 0;
  56 unsigned int oplockEnabled = 1;
  57 unsigned int experimEnabled = 0;
  58 unsigned int linuxExtEnabled = 1;
  59 unsigned int lookupCacheEnabled = 1;
  60 unsigned int multiuser_mount = 0;
  61 unsigned int global_secflags = CIFSSEC_DEF;
  62 /* unsigned int ntlmv2_support = 0; */
  63 unsigned int sign_CIFS_PDUs = 1;
  64 static const struct super_operations cifs_super_ops;
  65 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  66 module_param(CIFSMaxBufSize, int, 0);
  67 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
  68                                  "Default: 16384 Range: 8192 to 130048");
  69 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  70 module_param(cifs_min_rcv, int, 0);
  71 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  72                                 "1 to 64");
  73 unsigned int cifs_min_small = 30;
  74 module_param(cifs_min_small, int, 0);
  75 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  76                                  "Range: 2 to 256");
  77 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  78 module_param(cifs_max_pending, int, 0);
  79 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  80                                    "Default: 50 Range: 2 to 256");
  81
  82 extern mempool_t *cifs_sm_req_poolp;
  83 extern mempool_t *cifs_req_poolp;
  84 extern mempool_t *cifs_mid_poolp;
  85
  86 static int
  87 cifs_read_super(struct super_block *sb, void *data,
  88                 const char *devname, int silent)
  89 {
  90         struct inode *inode;
  91         struct cifs_sb_info *cifs_sb;
  92         int rc = 0;
  93
  94         /* BB should we make this contingent on mount parm? */
  95         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
  96         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
  97         cifs_sb = CIFS_SB(sb);
  98         if (cifs_sb == NULL)
  99                 return -ENOMEM;
 100
 101         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
 102         if (rc) {
 103                 kfree(cifs_sb);
 104                 return rc;
 105         }
 106
 107 #ifdef CONFIG_CIFS_DFS_UPCALL
 108         /* copy mount params to sb for use in submounts */
 109         /* BB: should we move this after the mount so we
 110          * do not have to do the copy on failed mounts?
 111          * BB: May be it is better to do simple copy before
 112          * complex operation (mount), and in case of fail
 113          * just exit instead of doing mount and attempting
 114          * undo it if this copy fails?*/
 115         if (data) {
 116                 int len = strlen(data);
 117                 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
 118                 if (cifs_sb->mountdata == NULL) {
 119                         bdi_destroy(&cifs_sb->bdi);
 120                         kfree(sb->s_fs_info);
 121                         sb->s_fs_info = NULL;
 122                         return -ENOMEM;
 123                 }
 124                 strncpy(cifs_sb->mountdata, data, len + 1);
 125                 cifs_sb->mountdata[len] = '\0';
 126         }
 127 #endif
 128
 129         rc = cifs_mount(sb, cifs_sb, data, devname);
 130
 131         if (rc) {
 132                 if (!silent)
 133                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
 134                 goto out_mount_failed;
 135         }
 136
 137         sb->s_magic = CIFS_MAGIC_NUMBER;
 138         sb->s_op = &cifs_super_ops;
 139         sb->s_bdi = &cifs_sb->bdi;
 140 /*      if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
 141             sb->s_blocksize =
 142                 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 143         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 144         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 145         inode = cifs_root_iget(sb, ROOT_I);
 146
 147         if (IS_ERR(inode)) {
 148                 rc = PTR_ERR(inode);
 149                 inode = NULL;
 150                 goto out_no_root;
 151         }
 152
 153         sb->s_root = d_alloc_root(inode);
 154
 155         if (!sb->s_root) {
 156                 rc = -ENOMEM;
 157                 goto out_no_root;
 158         }
 159
 160 #ifdef CONFIG_CIFS_EXPERIMENTAL
 161         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 162                 cFYI(1, "export ops supported");
 163                 sb->s_export_op = &cifs_export_ops;
 164         }
 165 #endif /* EXPERIMENTAL */
 166
 167         return 0;
 168
 169 out_no_root:
 170         cERROR(1, "cifs_read_super: get root inode failed");
 171         if (inode)
 172                 iput(inode);
 173
 174         cifs_umount(sb, cifs_sb);
 175
 176 out_mount_failed:
 177         if (cifs_sb) {
 178 #ifdef CONFIG_CIFS_DFS_UPCALL
 179                 if (cifs_sb->mountdata) {
 180                         kfree(cifs_sb->mountdata);
 181                         cifs_sb->mountdata = NULL;
 182                 }
 183 #endif
 184                 unload_nls(cifs_sb->local_nls);
 185                 bdi_destroy(&cifs_sb->bdi);
 186                 kfree(cifs_sb);
 187         }
 188         return rc;
 189 }
 190
 191 static void
 192 cifs_put_super(struct super_block *sb)
 193 {
 194         int rc = 0;
 195         struct cifs_sb_info *cifs_sb;
 196
 197         cFYI(1, "In cifs_put_super");
 198         cifs_sb = CIFS_SB(sb);
 199         if (cifs_sb == NULL) {
 200                 cFYI(1, "Empty cifs superblock info passed to unmount");
 201                 return;
 202         }
 203
 204         lock_kernel();
 205
 206         rc = cifs_umount(sb, cifs_sb);
 207         if (rc)
 208                 cERROR(1, "cifs_umount failed with return code %d", rc);
 209 #ifdef CONFIG_CIFS_DFS_UPCALL
 210         if (cifs_sb->mountdata) {
 211                 kfree(cifs_sb->mountdata);
 212                 cifs_sb->mountdata = NULL;
 213         }
 214 #endif
 215
 216         unload_nls(cifs_sb->local_nls);
 217         bdi_destroy(&cifs_sb->bdi);
 218         kfree(cifs_sb);
 219
 220         unlock_kernel();
 221 }
 222
 223 static int
 224 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 225 {
 226         struct super_block *sb = dentry->d_sb;
 227         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 228         struct cifsTconInfo *tcon = cifs_sb->tcon;
 229         int rc = -EOPNOTSUPP;
 230         int xid;
 231
 232         xid = GetXid();
 233
 234         buf->f_type = CIFS_MAGIC_NUMBER;
 235
 236         /*
 237          * PATH_MAX may be too long - it would presumably be total path,
 238          * but note that some servers (includinng Samba 3) have a shorter
 239          * maximum path.
 240          *
 241          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
 242          */
 243         buf->f_namelen = PATH_MAX;
 244         buf->f_files = 0;       /* undefined */
 245         buf->f_ffree = 0;       /* unlimited */
 246
 247         /*
 248          * We could add a second check for a QFS Unix capability bit
 249          */
 250         if ((tcon->ses->capabilities & CAP_UNIX) &&
 251             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
 252                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
 253
 254         /*
 255          * Only need to call the old QFSInfo if failed on newer one,
 256          * e.g. by OS/2.
 257          **/
 258         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
 259                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
 260
 261         /*
 262          * Some old Windows servers also do not support level 103, retry with
 263          * older level one if old server failed the previous call or we
 264          * bypassed it because we detected that this was an older LANMAN sess
 265          */
 266         if (rc)
 267                 rc = SMBOldQFSInfo(xid, tcon, buf);
 268
 269         FreeXid(xid);
 270         return 0;
 271 }
 272
 273 static int cifs_permission(struct inode *inode, int mask)
 274 {
 275         struct cifs_sb_info *cifs_sb;
 276
 277         cifs_sb = CIFS_SB(inode->i_sb);
 278
 279         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 280                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 281                         return -EACCES;
 282                 else
 283                         return 0;
 284         } else /* file mode might have been restricted at mount time
 285                 on the client (above and beyond ACL on servers) for
 286                 servers which do not support setting and viewing mode bits,
 287                 so allowing client to check permissions is useful */
 288                 return generic_permission(inode, mask, NULL);
 289 }
 290
 291 static struct kmem_cache *cifs_inode_cachep;
 292 static struct kmem_cache *cifs_req_cachep;
 293 static struct kmem_cache *cifs_mid_cachep;
 294 static struct kmem_cache *cifs_sm_req_cachep;
 295 mempool_t *cifs_sm_req_poolp;
 296 mempool_t *cifs_req_poolp;
 297 mempool_t *cifs_mid_poolp;
 298
 299 static struct inode *
 300 cifs_alloc_inode(struct super_block *sb)
 301 {
 302         struct cifsInodeInfo *cifs_inode;
 303         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 304         if (!cifs_inode)
 305                 return NULL;
 306         cifs_inode->cifsAttrs = 0x20;   /* default */
 307         cifs_inode->time = 0;
 308         cifs_inode->write_behind_rc = 0;
 309         /* Until the file is open and we have gotten oplock
 310         info back from the server, can not assume caching of
 311         file data or metadata */
 312         cifs_inode->clientCanCacheRead = false;
 313         cifs_inode->clientCanCacheAll = false;
 314         cifs_inode->delete_pending = false;
 315         cifs_inode->invalid_mapping = false;
 316         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 317         cifs_inode->server_eof = 0;
 318
 319         /* Can not set i_flags here - they get immediately overwritten
 320            to zero by the VFS */
 321 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
 322         INIT_LIST_HEAD(&cifs_inode->openFileList);
 323         return &cifs_inode->vfs_inode;
 324 }
 325
 326 static void
 327 cifs_destroy_inode(struct inode *inode)
 328 {
 329         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 330 }
 331
 332 static void
 333 cifs_clear_inode(struct inode *inode)
 334 {
 335         cifs_fscache_release_inode_cookie(inode);
 336 }
 337
 338 static void
 339 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 340 {
 341         seq_printf(s, ",addr=");
 342
 343         switch (server->addr.sockAddr.sin_family) {
 344         case AF_INET:
 345                 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
 346                 break;
 347         case AF_INET6:
 348                 seq_printf(s, "%pI6",
 349                            &server->addr.sockAddr6.sin6_addr.s6_addr);
 350                 if (server->addr.sockAddr6.sin6_scope_id)
 351                         seq_printf(s, "%%%u",
 352                                    server->addr.sockAddr6.sin6_scope_id);
 353                 break;
 354         default:
 355                 seq_printf(s, "(unknown)");
 356         }
 357 }
 358
 359 /*
 360  * cifs_show_options() is for displaying mount options in /proc/mounts.
 361  * Not all settable options are displayed but most of the important
 362  * ones are.
 363  */
 364 static int
 365 cifs_show_options(struct seq_file *s, struct vfsmount *m)
 366 {
 367         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
 368         struct cifsTconInfo *tcon = cifs_sb->tcon;
 369
 370         seq_printf(s, ",unc=%s", tcon->treeName);
 371         if (tcon->ses->userName)
 372                 seq_printf(s, ",username=%s", tcon->ses->userName);
 373         if (tcon->ses->domainName)
 374                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
 375
 376         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
 377         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 378                 seq_printf(s, ",forceuid");
 379         else
 380                 seq_printf(s, ",noforceuid");
 381
 382         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
 383         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 384                 seq_printf(s, ",forcegid");
 385         else
 386                 seq_printf(s, ",noforcegid");
 387
 388         cifs_show_address(s, tcon->ses->server);
 389
 390         if (!tcon->unix_ext)
 391                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
 392                                            cifs_sb->mnt_file_mode,
 393                                            cifs_sb->mnt_dir_mode);
 394         if (tcon->seal)
 395                 seq_printf(s, ",seal");
 396         if (tcon->nocase)
 397                 seq_printf(s, ",nocase");
 398         if (tcon->retry)
 399                 seq_printf(s, ",hard");
 400         if (cifs_sb->prepath)
 401                 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
 402         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 403                 seq_printf(s, ",posixpaths");
 404         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 405                 seq_printf(s, ",setuids");
 406         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 407                 seq_printf(s, ",serverino");
 408         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 409                 seq_printf(s, ",directio");
 410         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 411                 seq_printf(s, ",nouser_xattr");
 412         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 413                 seq_printf(s, ",mapchars");
 414         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 415                 seq_printf(s, ",sfu");
 416         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 417                 seq_printf(s, ",nobrl");
 418         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 419                 seq_printf(s, ",cifsacl");
 420         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 421                 seq_printf(s, ",dynperm");
 422         if (m->mnt_sb->s_flags & MS_POSIXACL)
 423                 seq_printf(s, ",acl");
 424
 425         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
 426         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
 427
 428         return 0;
 429 }
 430
 431 static void cifs_umount_begin(struct super_block *sb)
 432 {
 433         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 434         struct cifsTconInfo *tcon;
 435
 436         if (cifs_sb == NULL)
 437                 return;
 438
 439         tcon = cifs_sb->tcon;
 440         if (tcon == NULL)
 441                 return;
 442
 443         read_lock(&cifs_tcp_ses_lock);
 444         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 445                 /* we have other mounts to same share or we have
 446                    already tried to force umount this and woken up
 447                    all waiting network requests, nothing to do */
 448                 read_unlock(&cifs_tcp_ses_lock);
 449                 return;
 450         } else if (tcon->tc_count == 1)
 451                 tcon->tidStatus = CifsExiting;
 452         read_unlock(&cifs_tcp_ses_lock);
 453
 454         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 455         /* cancel_notify_requests(tcon); */
 456         if (tcon->ses && tcon->ses->server) {
 457                 cFYI(1, "wake up tasks now - umount begin not complete");
 458                 wake_up_all(&tcon->ses->server->request_q);
 459                 wake_up_all(&tcon->ses->server->response_q);
 460                 msleep(1); /* yield */
 461                 /* we have to kick the requests once more */
 462                 wake_up_all(&tcon->ses->server->response_q);
 463                 msleep(1);
 464         }
 465
 466         return;
 467 }
 468
 469 #ifdef CONFIG_CIFS_STATS2
 470 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 471 {
 472         /* BB FIXME */
 473         return 0;
 474 }
 475 #endif
 476
 477 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 478 {
 479         *flags |= MS_NODIRATIME;
 480         return 0;
 481 }
 482
 483 void cifs_drop_inode(struct inode *inode)
 484 {
 485         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 486
 487         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 488                 return generic_drop_inode(inode);
 489
 490         return generic_delete_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         .clear_inode    = cifs_clear_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 #ifdef CONFIG_CIFS_DFS_UPCALL
 938         rc = cifs_init_dns_resolver();
 939         if (rc)
 940                 goto out_unregister_key_type;
 941 #endif
 942         rc = slow_work_register_user(THIS_MODULE);
 943         if (rc)
 944                 goto out_unregister_resolver_key;
 945
 946         return 0;
 947
 948  out_unregister_resolver_key:
 949 #ifdef CONFIG_CIFS_DFS_UPCALL
 950         cifs_exit_dns_resolver();
 951  out_unregister_key_type:
 952 #endif
 953 #ifdef CONFIG_CIFS_UPCALL
 954         unregister_key_type(&cifs_spnego_key_type);
 955  out_unregister_filesystem:
 956 #endif
 957         unregister_filesystem(&cifs_fs_type);
 958  out_destroy_request_bufs:
 959         cifs_destroy_request_bufs();
 960  out_destroy_mids:
 961         cifs_destroy_mids();
 962  out_destroy_inodecache:
 963         cifs_destroy_inodecache();
 964  out_clean_proc:
 965         cifs_proc_clean();
 966         cifs_fscache_unregister();
 967  out:
 968         return rc;
 969 }
 970
 971 static void __exit
 972 exit_cifs(void)
 973 {
 974         cFYI(DBG2, "exit_cifs");
 975         cifs_proc_clean();
 976         cifs_fscache_unregister();
 977 #ifdef CONFIG_CIFS_DFS_UPCALL
 978         cifs_dfs_release_automount_timer();
 979         cifs_exit_dns_resolver();
 980 #endif
 981 #ifdef CONFIG_CIFS_UPCALL
 982         unregister_key_type(&cifs_spnego_key_type);
 983 #endif
 984         unregister_filesystem(&cifs_fs_type);
 985         cifs_destroy_inodecache();
 986         cifs_destroy_mids();
 987         cifs_destroy_request_bufs();
 988 }
 989
 990 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
 991 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
 992 MODULE_DESCRIPTION
 993     ("VFS to access servers complying with the SNIA CIFS Specification "
 994      "e.g. Samba and Windows");
 995 MODULE_VERSION(CIFS_VERSION);
 996 module_init(init_cifs)
 997 module_exit(exit_cifs)