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