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