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